4311 references to None
Analyzer.Utilities.UnitTests (2)
aspire (1)
Aspire.Cli.Tests (12)
Aspire.Dashboard (2)
Aspire.Dashboard.Tests (9)
Aspire.Hosting (4)
Aspire.Hosting.Azure.Tests (49)
Aspire.Hosting.Docker (1)
Aspire.Hosting.Keycloak.Tests (2)
Aspire.Hosting.PostgreSQL.Tests (2)
Aspire.Hosting.Testing (1)
Aspire.Hosting.Tests (135)
DistributedApplicationTests.cs (15)
136await orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
140await orchestrator.StopResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
144var restartResourceTask = orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
148await orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
198await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
215await orchestrator.StopResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
219await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
272await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
288await orchestrator.StopResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
292await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
353await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan);
371await orchestrator.StopResourceAsync(runningResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan);
378await orchestrator.StartResourceAsync(runningResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan);
677await orchestrator.StopResourceAsync(serviceA.Metadata.Name, CancellationToken.None).DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout);
682await orchestrator.StartResourceAsync(serviceA.Metadata.Name, CancellationToken.None).DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout);
Publishing\PublishingActivityReporterTests.cs (76)
27var step = await reporter.CreateStepAsync(title, CancellationToken.None);
58var step = await reporter.CreateStepAsync("Parent Step", CancellationToken.None);
65var task = await step.CreateTaskAsync(statusText, CancellationToken.None);
98() => nonExistentStep.CreateTaskAsync("Test Task", CancellationToken.None));
110var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
111await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None);
115() => step.CreateTaskAsync("Test Task", CancellationToken.None));
129var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
135await step.CompleteAsync(completionText, isError ? CompletionState.CompletedWithError : CompletionState.Completed, CancellationToken.None);
160var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
161var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
168await task.UpdateAsync(newStatusText, CancellationToken.None);
191var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
192var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
195var dummyStep = await reporter.CreateStepAsync("Dummy Step", CancellationToken.None);
202() => invalidTask.UpdateAsync("New status", CancellationToken.None));
213var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
214var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
215await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None);
219() => task.UpdateAsync("New status", CancellationToken.None));
232var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
233var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
240await task.CompleteAsync(completionMessage, cancellationToken: CancellationToken.None);
267var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
268var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
269await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None);
273() => task.CompleteAsync(null, cancellationToken: CancellationToken.None));
289await reporter.CompletePublishAsync(null, completionState, CancellationToken.None);
310await reporter.CompletePublishAsync(expectedStatusText, CompletionState.CompletedWithError, CancellationToken.None);
329var step1 = await reporter.CreateStepAsync("Step 1", CancellationToken.None);
330var step2 = await reporter.CreateStepAsync("Step 2", CancellationToken.None);
331var step3 = await reporter.CreateStepAsync("Step 3", CancellationToken.None);
333var task1 = await step1.CreateTaskAsync("Task 1", CancellationToken.None);
334await task1.CompleteAsync(null, cancellationToken: CancellationToken.None);
335await step1.CompleteAsync("Step 1 completed", CompletionState.Completed, CancellationToken.None);
337var task2 = await step2.CreateTaskAsync("Task 2", CancellationToken.None);
338await task2.CompleteAsync(null, cancellationToken: CancellationToken.None);
339await step2.CompleteAsync("Step 2 completed with warning", CompletionState.CompletedWithWarning, CancellationToken.None);
341var task3 = await step3.CreateTaskAsync("Task 3", CancellationToken.None);
342await task3.CompleteAsync(null, cancellationToken: CancellationToken.None);
343await step3.CompleteAsync("Step 3 failed", CompletionState.CompletedWithError, CancellationToken.None);
350await reporter.CompletePublishAsync(cancellationToken: CancellationToken.None);
366var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
367var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
370await task.CompleteAsync(null, cancellationToken: CancellationToken.None);
383var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
384var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
387await task.CompleteAsync(null, cancellationToken: CancellationToken.None);
391() => task.CompleteAsync(null, cancellationToken: CancellationToken.None));
403var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
406await step.CompleteAsync("Complete", cancellationToken: CancellationToken.None);
410() => step.CompleteAsync("Complete again", cancellationToken: CancellationToken.None));
422var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
423var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
426await task.CompleteAsync(null, cancellationToken: CancellationToken.None);
429await step.CompleteAsync("Step completed", CompletionState.Completed, CancellationToken.None);
434() => task.UpdateAsync("New status", CancellationToken.None));
440() => task.CompleteAsync(null, cancellationToken: CancellationToken.None));
445() => step.CreateTaskAsync("New Task", CancellationToken.None));
455await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
516await reporter.CompleteInteractionAsync(promptId, responses, CancellationToken.None).DefaultTimeout();
529var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
544var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
572var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
573var task1 = await step.CreateTaskAsync("Task 1", CancellationToken.None);
574var task2 = await step.CreateTaskAsync("Task 2", CancellationToken.None);
577await task1.SucceedAsync(null, CancellationToken.None);
578await task2.SucceedAsync(null, CancellationToken.None);
606var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
609await step.CompleteAsync("Step completed manually", CompletionState.Completed, CancellationToken.None);
631var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
632var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
640await taskInternal.WarnAsync(completionMessage, CancellationToken.None);
666var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
667var task = await step.CreateTaskAsync("Test Task", CancellationToken.None);
675await taskInternal.FailAsync(completionMessage, CancellationToken.None);
Publishing\PublishingExtensionsTests.cs (16)
19await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
22var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
38await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
41var result = await step.SucceedAsync("Success message", CancellationToken.None);
56await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
57var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
60var result = await task.UpdateStatusAsync("Updated status", CancellationToken.None);
75await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
76var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
79var result = await task.SucceedAsync("Success message", CancellationToken.None);
93await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
94var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
97var result = await task.WarnAsync("Warning message", CancellationToken.None);
111await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None);
112var task = await step.CreateTaskAsync("Initial status", CancellationToken.None);
115await task.FailAsync("Error message", CancellationToken.None);
Aspire.Hosting.Yarp.Tests (1)
Aspire.StackExchange.Redis.DistributedCaching.Tests (1)
Aspire.StackExchange.Redis.OutputCaching.Tests (1)
AuthSamples.FunctionalTests (1)
BuildActionTelemetryTable (4)
BuildValidator (1)
Client.ChannelLayer.IntegrationTests (2)
Client.TypedClient.IntegrationTests (5)
CodeStyleConfigFileGenerator (2)
ConfigurationSchemaGenerator (2)
ConfigurationSchemaGenerator.Tests (1)
Contract.Service.IntegrationTests (8)
ServiceContractTests.4.0.0.cs (4)
336Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Open_ChannelFactory(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
389Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Open_Proxy(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
440Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Close_ChannelFactory(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
490Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Close_Proxy(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
ServiceContractTests.4.1.0.cs (4)
210Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
224Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_Async(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
614Task.Factory.StartNew(() => ServiceContractTests.NetTcp_NoSecurity_Streamed_RoundTrips_String(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
628Task.Factory.StartNew(() => ServiceContractTests.NetTcp_NoSecurity_Streamed_Async_RoundTrips_String(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();
dotnet-svcutil-lib (19)
FrameworkFork\System.ServiceModel\Internals\System\Runtime\TaskHelpers.cs (4)
47}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
68}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
92}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
124}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
dotnet-svcutil-lib.Tests (24)
MSBuildProjTests.cs (4)
41var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None);
61var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None);
80var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None);
100var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None);
ProjectUtils.cs (3)
17static readonly CancellationToken token = CancellationToken.None;
95result = ProcessRunner.RunAsync("dotnet-svcutil", options, project.DirectoryPath, redirectOutput: true, throwOnError: false, environmentVariables: envVars, logger: logger, cancellationToken: CancellationToken.None).Result;
156result = ProcessRunner.RunAsync("dotnet", $"run", project.DirectoryPath, redirectOutput: true, throwOnError: false, environmentVariables: envVars, logger: logger, cancellationToken: CancellationToken.None).Result;
TestInit.cs (4)
178ProcessRunner.ProcessResult ret = ProcessRunner.TryRunAsync("dotnet", "tool uninstall -g dotnet-svcutil", currentDirectory, null, CancellationToken.None).Result;
185ret = ProcessRunner.TryRunAsync("dotnet", $"tool install --global --add-source {pkgPath} dotnet-svcutil --version {g_SvcutilPkgVersion}", currentDirectory, null, CancellationToken.None).Result;
259this_TestCaseProject = MSBuildProj.FromPathAsync(projectPath, null, CancellationToken.None).Result;
589var rootSolutionFolder = PathHelper.TryFindFileAsync("dotnet-svcutil.sln", parentDir, null, CancellationToken.None).Result;
GenerateDocumentationAndConfigFiles (23)
http2cat (2)
IdeBenchmarks (10)
IdeCoreBenchmarks (22)
SyntacticChangeRangeBenchmark.cs (6)
91SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None);
98SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None);
104SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, _rootWithSimpleEdit, TimeSpan.MaxValue, CancellationToken.None);
110SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, _rootWithComplexEdit, TimeSpan.MaxValue, CancellationToken.None);
117SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None);
124SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None);
IIS.FunctionalTests (2)
IIS.LongTests (2)
IIS.NewHandler.FunctionalTests (2)
IIS.NewShim.FunctionalTests (2)
IIS.ShadowCopy.Tests (1)
IISExpress.FunctionalTests (2)
InMemory.FunctionalTests (14)
InProcessWebSite (4)
Interop.FunctionalTests (43)
Http3\Http3RequestTests.cs (32)
94var response1 = await client.SendAsync(request1, CancellationToken.None);
154var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();
256var response = await client.SendAsync(request, CancellationToken.None);
300var responseTask = client.SendAsync(request, CancellationToken.None).DefaultTimeout();
380var responseTask = client.SendAsync(request, CancellationToken.None).DefaultTimeout();
424var responseTask = client.SendAsync(request, CancellationToken.None);
566var sendTask = client.SendAsync(request, CancellationToken.None);
625var sendTask = client.SendAsync(request, CancellationToken.None);
681var ex = await Assert.ThrowsAnyAsync<HttpRequestException>(() => client.SendAsync(request, CancellationToken.None)).DefaultTimeout();
820var response = await client.SendAsync(request, CancellationToken.None);
856var response1 = await client.SendAsync(request1, CancellationToken.None);
867var response2 = await client.SendAsync(request2, CancellationToken.None);
916var response1 = await client.SendAsync(request1, CancellationToken.None);
929var response2 = await client.SendAsync(request2, CancellationToken.None);
945var response3 = await client.SendAsync(request3, CancellationToken.None);
1375var response = await client.SendAsync(request, CancellationToken.None);
1427var response1 = await client.SendAsync(request1, CancellationToken.None);
1437var response2 = await client.SendAsync(request2, CancellationToken.None);
1494var response1 = await client.SendAsync(request1, CancellationToken.None);
1505var response2 = await client.SendAsync(request2, CancellationToken.None);
1551await client.SendAsync(request1, CancellationToken.None);
1565var response2 = await client.SendAsync(request2, CancellationToken.None);
1608var response1 = await client.SendAsync(request1, CancellationToken.None);
1668var response1 = await client.SendAsync(request1, CancellationToken.None);
1724var response1 = await client.SendAsync(request1, CancellationToken.None);
1781var responseTask1 = client.SendAsync(CreateHttp3Request(HttpMethod.Get, $"https://127.0.0.1:{port}/1"), CancellationToken.None);
1831var response3 = await client.SendAsync(CreateHttp3Request(HttpMethod.Get, $"https://127.0.0.1:{port}/3"), CancellationToken.None);
1890var responseTask = client.SendAsync(request1, CancellationToken.None);
1967var response1 = await client.SendAsync(request1, CancellationToken.None);
2045var responseTask = client.SendAsync(request, CancellationToken.None);
2145var responseTask = client.SendAsync(request, CancellationToken.None);
2197var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();
Metrics (29)
Metrics.Legacy (29)
Microsoft.Analyzers.Extra.Tests (17)
Microsoft.Analyzers.Local.Tests (7)
Microsoft.Arcade.Common (2)
Microsoft.AspNetCore.Analyzer.Testing (2)
Microsoft.AspNetCore.App.Analyzers.Test (10)
Microsoft.AspNetCore.Components.Analyzers.Tests (2)
Microsoft.AspNetCore.Components.Forms (1)
Microsoft.AspNetCore.Components.SdkAnalyzers.Tests (2)
Microsoft.AspNetCore.Components.Server (2)
Microsoft.AspNetCore.Components.Server.Tests (14)
Circuits\RemoteJSDataStreamTest.cs (10)
24var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(_jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None).DefaultTimeout();
162var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None);
182var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None);
219cancellationToken: CancellationToken.None);
260cancellationToken: CancellationToken.None);
296var token1 = isToken1Cancelable ? cts.Token : CancellationToken.None;
297var token2 = isToken1Cancelable ? CancellationToken.None : cts.Token;
313CancellationToken.None,
314CancellationToken.None);
348var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime ?? _jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None);
Microsoft.AspNetCore.Components.Web (1)
Microsoft.AspNetCore.Components.WebAssembly (1)
Microsoft.AspNetCore.Components.WebAssembly.Tests (3)
Microsoft.AspNetCore.Components.WebView.Photino (2)
Microsoft.AspNetCore.Connections.Abstractions (2)
Microsoft.AspNetCore.DataProtection (3)
Microsoft.AspNetCore.DataProtection.Tests (22)
KeyManagement\KeyRingBasedDataProtectorTests.cs (5)
263var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key });
294var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key });
298var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 });
330var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key });
334var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 });
KeyManagement\KeyRingProviderTests.cs (16)
163getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None },
248getCacheExpirationTokenReturnValues: new[] { CancellationToken.None },
501getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None },
536getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None },
582expirationToken: CancellationToken.None,
609expirationToken: CancellationToken.None,
615expirationToken: CancellationToken.None,
621expirationToken: CancellationToken.None,
650expirationToken: CancellationToken.None,
656expirationToken: CancellationToken.None,
701expirationToken: CancellationToken.None,
738.Returns(new CacheableKeyRing(CancellationToken.None, StringToDateTime("2015-03-02 00:00:00Z"), updatedKeyRing));
831expirationToken: CancellationToken.None,
Microsoft.AspNetCore.Grpc.JsonTranscoding (4)
Microsoft.AspNetCore.Hosting.Abstractions (1)
Microsoft.AspNetCore.Http (1)
Microsoft.AspNetCore.Http.Connections (1)
Microsoft.AspNetCore.Http.Connections.Client (3)
Microsoft.AspNetCore.Http.Connections.Tests (18)
WebSocketsTests.cs (8)
51cancellationToken: CancellationToken.None);
52await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
100await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
193await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
298await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout();
332await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout();
376var transport = ws.ProcessRequestAsync(context, CancellationToken.None);
386await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout();
Microsoft.AspNetCore.Http.Extensions.Tests (5)
SendFileResponseExtensionsTests.cs (5)
26await response.SendFileAsync("bob", 1, 3, CancellationToken.None);
31Assert.Equal(CancellationToken.None, fakeFeature.Token);
42await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None);
82await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None);
97await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None);
Microsoft.AspNetCore.Http.Results.Tests (5)
Microsoft.AspNetCore.HttpOverrides (1)
Microsoft.AspNetCore.Identity (4)
Microsoft.AspNetCore.Identity.FunctionalTests (1)
Microsoft.AspNetCore.Identity.Test (91)
RoleManagerTest.cs (9)
17store.Setup(s => s.CreateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
18store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable();
19store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
37store.Setup(s => s.UpdateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
38store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable();
39store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
65store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable();
82store.Setup(s => s.FindByNameAsync(role.Name, CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable();
101store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable();
UserManagerTest.cs (82)
72store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
73store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable();
74store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
91store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
92store.Setup(s => s.GetSecurityStampAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.SecurityStamp)).Verifiable();
93store.Setup(s => s.SetSecurityStampAsync(user, It.IsAny<string>(), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
111store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
112store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable();
113store.Setup(s => s.GetEmailAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.Email)).Verifiable();
114store.Setup(s => s.SetNormalizedEmailAsync(user, normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
115store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
135store.Setup(s => s.DeleteAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
162store.Setup(s => s.DeleteAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Failed(new IdentityErrorDescriber().ConcurrencyFailure())).Verifiable();
188store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable();
189store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
190store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
208store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable();
209store.Setup(s => s.GetEmailAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.Email)).Verifiable();
210store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
211store.Setup(s => s.SetNormalizedEmailAsync(user, normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
212store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
230store.Setup(s => s.SetUserNameAsync(user, "foo", CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
231store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult("foo")).Verifiable();
232store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName("foo"), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
233store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
250store.Setup(s => s.FindByIdAsync(user.Id, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
268store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
285store.Setup(s => s.FindByNameAsync(user.UserName, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
304store.Setup(s => s.FindByEmailAsync(normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
321store.Setup(s => s.FindByEmailAsync(user.Email, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
345store.Setup(s => s.FindByEmailAsync("@Foo", CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
363store.Setup(s => s.FindByNameAsync("#Foo", CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
383store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
386store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
389store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None))
393store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
394store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
397store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
400store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None))
411store.Verify(s => s.AddToRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None), Times.Once());
421store.Setup(s => s.AddToRoleAsync(user, "#A", CancellationToken.None))
424store.Setup(s => s.AddToRoleAsync(user, "#B", CancellationToken.None))
427store.Setup(s => s.AddToRoleAsync(user, "#C", CancellationToken.None))
431store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
432store.Setup(s => s.IsInRoleAsync(user, "#A", CancellationToken.None))
435store.Setup(s => s.IsInRoleAsync(user, "#B", CancellationToken.None))
438store.Setup(s => s.IsInRoleAsync(user, "#C", CancellationToken.None))
450store.Verify(s => s.AddToRoleAsync(user, "#C", CancellationToken.None), Times.Once());
461store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
464store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
485store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
488store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
491store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None))
494store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
495store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
498store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
501store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None))
522store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
525store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None))
528store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None))
548store.Setup(s => s.AddClaimsAsync(user, claims, CancellationToken.None))
551store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
572store.Setup(s => s.AddClaimsAsync(user, It.IsAny<IEnumerable<Claim>>(), CancellationToken.None))
575store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
604store.Setup(s => s.ReplaceClaimAsync(user, It.IsAny<Claim>(), It.IsAny<Claim>(), CancellationToken.None))
607store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
640store.Setup(s => s.GetPasswordHashAsync(user, CancellationToken.None))
643store.Setup(s => s.SetPasswordHashAsync(user, It.IsAny<string>(), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
735store.Setup(s => s.RemoveClaimsAsync(user, claims, CancellationToken.None))
738store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
766store.Setup(s => s.RemoveClaimsAsync(user, It.IsAny<IEnumerable<Claim>>(), CancellationToken.None))
769store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
794store.Setup(s => s.SetPasskeyAsync(user, passkey, CancellationToken.None)).Returns(Task.CompletedTask).Verifiable();
795store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
814store.Setup(s => s.GetPasskeysAsync(user, CancellationToken.None)).Returns(Task.FromResult(passkeys)).Verifiable();
832store.Setup(s => s.FindByPasskeyIdAsync(credentialId, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
850store.Setup(s => s.RemovePasskeyAsync(user, credentialId, CancellationToken.None)).Returns(Task.CompletedTask).Verifiable();
851store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
2159store.Setup(s => s.FindByEmailAsync("DUPE@EMAIL.COM", CancellationToken.None))
2162store.Setup(s => s.GetUserIdAsync(user2, CancellationToken.None))
2165store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None))
2168store.Setup(s => s.GetEmailAsync(user, CancellationToken.None))
Microsoft.AspNetCore.Identity.UI (8)
Microsoft.AspNetCore.Mvc.Core.Test (5)
Microsoft.AspNetCore.Mvc.Formatters.Xml (4)
Microsoft.AspNetCore.Mvc.NewtonsoftJson (2)
Microsoft.AspNetCore.OutputCaching (1)
Microsoft.AspNetCore.OutputCaching.Microbenchmarks (6)
EndToEndBenchmarks.cs (6)
130await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None);
140await WriteInRandomChunksAsync(Payload, oc, CancellationToken.None);
146await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None);
157await WriteInRandomChunks(Payload, pipe, CancellationToken.None);
163await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None);
174var entry = await OutputCacheEntryFormatter.GetAsync(Key, _store, CancellationToken.None);
Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (1)
Microsoft.AspNetCore.OutputCaching.Tests (1)
Microsoft.AspNetCore.Owin (3)
Microsoft.AspNetCore.Owin.Tests (1)
Microsoft.AspNetCore.ResponseCaching (2)
Microsoft.AspNetCore.ResponseCaching.Microbenchmarks (2)
Microsoft.AspNetCore.ResponseCompression (1)
Microsoft.AspNetCore.ResponseCompression.Tests (4)
Microsoft.AspNetCore.Server.HttpSys (5)
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (33)
ResponseSendFileTests.cs (17)
45await sendFile.SendFileAsync(string.Empty, 0, null, CancellationToken.None);
68return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);
87return sendFile.SendFileAsync(RelativeFilePath, 0, null, CancellationToken.None);
106return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);
125sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None).Wait();
126return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);
145return sendFile.SendFileAsync(AbsoluteFilePath, 0, FileLength / 2, CancellationToken.None);
166sendFile.SendFileAsync(AbsoluteFilePath, 1234567, null, CancellationToken.None));
185sendFile.SendFileAsync(AbsoluteFilePath, 0, 1234567, CancellationToken.None));
202return sendFile.SendFileAsync(AbsoluteFilePath, 0, 0, CancellationToken.None);
222return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);
243return sendFile.SendFileAsync(AbsoluteFilePath, 0, 10, CancellationToken.None);
264return sendFile.SendFileAsync(AbsoluteFilePath, 0, 0, CancellationToken.None);
291return sendFile.SendFileAsync(AbsoluteFilePath, 0, 10, CancellationToken.None);
315await httpContext.Response.SendFileAsync(emptyFilePath, 0, null, CancellationToken.None);
317await httpContext.Response.Body.WriteAsync(new byte[10], 0, 10, CancellationToken.None);
650await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);
Microsoft.AspNetCore.Server.HttpSys.NonHelixTests (1)
Microsoft.AspNetCore.Server.IIS (1)
Microsoft.AspNetCore.Server.IntegrationTesting (1)
Microsoft.AspNetCore.Server.Kestrel.Core (1)
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (25)
AddressBinderTests.cs (5)
193AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None));
214var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);
242var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);
305await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);
336await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);
KestrelServerTests.cs (15)
352async () => await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None));
371await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
393async () => await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None));
416await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
442await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
469await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
500await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
528await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None);
577await server.StartAsync(new DummyApplication(), CancellationToken.None);
635await server.StartAsync(new DummyApplication(), CancellationToken.None);
826await server.StartAsync(new DummyApplication(), CancellationToken.None).DefaultTimeout();
905await server.StopAsync(CancellationToken.None).DefaultTimeout();
964await server.StartAsync(new DummyApplication(), CancellationToken.None).DefaultTimeout();
971await server.StopAsync(CancellationToken.None).DefaultTimeout();
986server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None).GetAwaiter().GetResult();
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (5)
Microsoft.AspNetCore.Shared.Tests (2)
Microsoft.AspNetCore.SignalR.Client.Core (66)
Microsoft.AspNetCore.SignalR.Core (37)
Microsoft.AspNetCore.SignalR.Tests (16)
EndToEndTests.cs (10)
100await ws.ConnectAsync(new Uri(socketUrl), CancellationToken.None).DefaultTimeout();
104await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None).DefaultTimeout();
108var result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout();
114await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout();
116result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout();
138await ws.ConnectAsync(new Uri(socketUrl), CancellationToken.None).DefaultTimeout();
143await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Binary, endOfMessage: false, CancellationToken.None).DefaultTimeout();
147var result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout();
153await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout();
155result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout();
Microsoft.AspNetCore.SpaServices.Extensions (1)
Microsoft.AspNetCore.SpaServices.Extensions.Tests (2)
Microsoft.AspNetCore.TestHost (1)
Microsoft.AspNetCore.TestHost.Tests (31)
TestClientTests.cs (25)
256var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.SendAsync(message, CancellationToken.None));
587var receiveResult = await websocket.ReceiveAsync(new System.ArraySegment<byte>(receiveArray), CancellationToken.None);
590await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None);
596await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None);
615var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None);
617await clientSocket.SendAsync(new System.ArraySegment<byte>(hello), WebSocketMessageType.Text, true, CancellationToken.None);
619await clientSocket.SendAsync(new System.ArraySegment<byte>(world), WebSocketMessageType.Binary, true, CancellationToken.None);
620await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None);
626var result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None);
631result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None);
636result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None);
658await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None);
667await websocket.CloseAsync(WebSocketCloseStatus.InternalServerError, closeReason, CancellationToken.None);
682var clientSocket = await client.ConnectAsync(new Uri("wss://localhost"), CancellationToken.None);
684var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
709var receiveResult = await websocket.ReceiveAsync(new ArraySegment<byte>(receiveArray), CancellationToken.None);
712await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None);
718await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None);
774var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None);
776await Assert.ThrowsAsync<IOException>(async () => await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None));
793var receiveResult = await websocket.ReceiveAsync(new System.ArraySegment<byte>(receiveArray), CancellationToken.None);
795await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None);
807var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None);
809await clientSocket.SendAsync(new System.ArraySegment<byte>(hello), WebSocketMessageType.Text, true, CancellationToken.None);
816var result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None);
Microsoft.AspNetCore.WebSockets.Tests (74)
SendReceiveTests.cs (11)
19await pair.ClientSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None);
22var result = await pair.ServerSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
36await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None);
39var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
51await pair.ClientSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None);
54var result = await pair.ServerSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
66await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None);
69var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
81await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None);
84var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
94await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
WebSocketMiddlewareTests.cs (61)
29await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
49await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
71var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
79await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
81await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
96var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
105await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
106await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
121var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
130await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
131await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
147var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
158await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
159await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
178var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
186new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
194new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None);
205await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
206await client.SendAsync(new ArraySegment<byte>(originalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
209await client.SendAsync(new ArraySegment<byte>(originalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
212await client.SendAsync(new ArraySegment<byte>(originalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
226await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
231await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
233var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
251await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
256await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
258var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
276await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None);
281await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
287result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer, receivedCount, clientBuffer.Length - receivedCount), CancellationToken.None);
309await webSocket.SendAsync(new ArraySegment<byte>(originalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
310await webSocket.SendAsync(new ArraySegment<byte>(originalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None);
311await webSocket.SendAsync(new ArraySegment<byte>(originalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None);
316await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
318var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
325new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
332new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None);
353var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
363await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
364await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
380await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
385await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
387var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
409var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
416await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
421await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
422await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
439var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
446await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
451await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
452await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
455await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
470await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None);
473var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None);
483await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
485var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None);
494await client.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
558await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
625await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
735await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
793await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
Microsoft.AspNetCore.WebUtilities (2)
Microsoft.Build.Framework (2)
Microsoft.Build.Tasks.CodeAnalysis (2)
Microsoft.Build.Tasks.CodeAnalysis.Sdk (2)
Microsoft.CodeAnalysis (12)
DiagnosticAnalyzer\CompilationWithAnalyzers.cs (7)
67public CancellationToken CancellationToken => CancellationToken.None;
235return GetAnalyzerDiagnosticsAsync(CancellationToken.None);
286return GetAllDiagnosticsAsync(CancellationToken.None);
1199var effectiveDiagnostic = compilation.Options.FilterDiagnostic(diagnostic, CancellationToken.None);
1241catch (Exception ex) when (AnalyzerExecutor.HandleAnalyzerException(ex, analyzer, info: null, wrappedOnAnalyzerException, analyzerExceptionFilter: null, CancellationToken.None))
1253catch (Exception ex) when (AnalyzerExecutor.HandleAnalyzerException(ex, suppressor, info: null, wrappedOnAnalyzerException, analyzerExceptionFilter: null, CancellationToken.None))
1260isEnabledWithAnalyzerConfigOptions: _ => false, getSupportedDiagnosticDescriptors, getSupportedSuppressionDescriptors, CancellationToken.None); ;
Microsoft.CodeAnalysis.Analyzers (23)
Microsoft.CodeAnalysis.AnalyzerUtilities (23)
Microsoft.CodeAnalysis.BannedApiAnalyzers (23)
Microsoft.CodeAnalysis.CodeStyle (19)
Microsoft.CodeAnalysis.CodeStyle.Fixes (1)
Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (2)
Microsoft.CodeAnalysis.Collections.Package (2)
Microsoft.CodeAnalysis.Contracts.Package (2)
Microsoft.CodeAnalysis.CSharp (7)
Microsoft.CodeAnalysis.CSharp.CodeStyle (1)
Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (1)
Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests (6)
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (2)
Microsoft.CodeAnalysis.CSharp.EditorFeatures (3)
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (123)
EditAndContinue\ActiveStatementTrackingServiceTests.cs (7)
72Assert.Same(snapshot1, document1.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot());
73Assert.Same(snapshot2, document2.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot());
88var spans2 = await trackingSession.GetSpansAsync(solution, document1.Id, document1.FilePath, CancellationToken.None);
91var spans3 = await trackingSession.GetSpansAsync(solution, document2.Id, document2.FilePath, CancellationToken.None);
95var spans4 = await trackingSession.GetAdjustedTrackingSpansAsync(document1, snapshot1, CancellationToken.None);
102AssertEx.Empty(await trackingSession.GetAdjustedTrackingSpansAsync(document2, snapshot2, CancellationToken.None));
119var spans6 = await trackingSession.GetAdjustedTrackingSpansAsync(document1, snapshot1, CancellationToken.None);
ExtractMethod\ExtractMethodBase.cs (7)
130CodeCleanupOptions = await document.GetCodeCleanupOptionsAsync(CancellationToken.None),
134document, testDocument.SelectedSpans.Single(), localFunction, options, CancellationToken.None);
150var (doc, _) = await result.GetDocumentAsync(CancellationToken.None);
167var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None);
170var (result, status) = await validator.GetValidSelectionAsync(CancellationToken.None);
192var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None);
199var (_, status) = await validator.GetValidSelectionAsync(CancellationToken.None);
PdbSourceDocument\PdbSourceDocumentLoaderServiceTests.cs (4)
45var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None);
73var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None);
PdbSourceDocument\PdbSourceDocumentTests.cs (8)
787var file = await service.GetGeneratedFileAsync(workspace, project, symbol, signaturesOnly: false, options: options, cancellationToken: CancellationToken.None).ConfigureAwait(false);
845var mainCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false);
868var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None);
889var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None);
911var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None);
932var fileOne = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None);
937var compilation = await project.GetCompilationAsync(CancellationToken.None);
939var fileTwo = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbolTwo, signaturesOnly: false, MetadataAsSourceOptions.Default, CancellationToken.None);
Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (7)
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (12)
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (6)
Emit\EditAndContinue\AssemblyReferencesTests.cs (2)
84compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None);
160compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (50)
Diagnostics\DiagnosticAnalyzerTests.cs (34)
3270var analysisResult = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzers, CancellationToken.None);
3316var analysisResult = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzers, CancellationToken.None);
3357var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None);
3608var diagnostics = await compWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, filterSpan: null, CancellationToken.None);
3700await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, analyzersToQuery, CancellationToken.None) :
3701await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzersToQuery, CancellationToken.None);
3706await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, CancellationToken.None) :
3707await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, CancellationToken.None);
3762CancellationToken.None);
3777CancellationToken.None);
3818CancellationToken.None);
3889var diagnostics = await compilation.WithAnalyzers(analyzers, options).GetAnalyzerDiagnosticsAsync(CancellationToken.None);
3892var analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile, CancellationToken.None);
3896analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(CancellationToken.None);
3931var diagnostics = await compilation.WithAnalyzers(analyzers, options).GetAnalyzerDiagnosticsAsync(CancellationToken.None);
3934var analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile1, CancellationToken.None);
3936analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile2, CancellationToken.None);
3940analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile1, singleAnalyzerArray, CancellationToken.None);
3942analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile2, singleAnalyzerArray, CancellationToken.None);
3945analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(CancellationToken.None);
4338? await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel.SyntaxTree, filterSpan, analyzers, CancellationToken.None)
4339: await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel.SyntaxTree, filterSpan, CancellationToken.None);
4344? await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(semanticModel.SyntaxTree, filterSpan, analyzers, CancellationToken.None)
4345: await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(semanticModel.SyntaxTree, filterSpan, CancellationToken.None);
4352? await compilationWithAnalyzers.GetAnalysisResultAsync(additionalTextFile, filterSpan, analyzers, CancellationToken.None)
4353: await compilationWithAnalyzers.GetAnalysisResultAsync(additionalTextFile, filterSpan, CancellationToken.None);
4360? await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan, analyzers, CancellationToken.None)
4361: await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan, CancellationToken.None);
4366? await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan, analyzers, CancellationToken.None)
4367: await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan, CancellationToken.None);
4400analyzerExceptionFilter: null, reportAnalyzer: false, severityFilter, trackSuppressedDiagnosticIds: false, out var newCompilation, CancellationToken.None);
4403_ = newCompilation.GetDiagnostics(CancellationToken.None);
4404_ = await driver.GetDiagnosticsAsync(newCompilation, CancellationToken.None);
4441var diagnostics = await compWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, filterSpan: null, CancellationToken.None);
Diagnostics\GetDiagnosticsTests.cs (13)
800tasks[i] = Task.Run(() => compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, null, CancellationToken.None));
853tasks[i] = Task.Run(() => compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, null, CancellationToken.None));
881var diagnostics = await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(tree, CancellationToken.None);
911_ = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None);
920_ = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan: null, CancellationToken.None);
964var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None);
1190var result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None);
1198result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan: null, CancellationToken.None);
1207result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None);
1251var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None);
1649var syntaxResult = await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, CancellationToken.None);
1678var result = await compilationWithAnalyzers.GetAnalysisResultAsync(model1, filterSpan: localDecl.Span, CancellationToken.None);
1824var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None);
Microsoft.CodeAnalysis.CSharp.Features (2)
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (26)
EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (2)
124return await analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newDocument.Project, baseActiveStatements, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, log, CancellationToken.None);
760var result = await analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newDocument.Project, baseActiveStatements, [], capabilities, log, CancellationToken.None);
SemanticSearch\CSharpSemanticSearchServiceTests.cs (9)
73var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None);
77var executeResult = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, traceSource, CancellationToken.None);
273var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None);
321var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None);
324var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, traceSource, CancellationToken.None);
389var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None);
392var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, traceSource, CancellationToken.None);
448var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None);
451var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, traceSource, CancellationToken.None);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (18)
Semantics\SemanticErrorTests.cs (6)
25163}, CancellationToken.None)
25171comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None)
25232}, CancellationToken.None)
25242comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None)
25322}, CancellationToken.None)
25336comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None)
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (29)
Microsoft.CodeAnalysis.CSharp.Workspaces (2)
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (32)
CodeGeneration\AddImportsTests.cs (12)
90? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, addImportOptions, CancellationToken.None)
91: await ImportAdder.AddImportsFromSyntaxesAsync(doc, addImportOptions, CancellationToken.None);
95var formatted = await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None);
102var reduced = await Simplifier.ReduceAsync(imported, simplifierOptions, CancellationToken.None);
103var formatted = await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None);
868var compilation = await document.Project.GetCompilationAsync(CancellationToken.None);
869var compilerDiagnostics = compilation.GetDiagnostics(CancellationToken.None);
874var syntaxRoot = await document.GetSyntaxRootAsync(CancellationToken.None).ConfigureAwait(false);
878var editor = await DocumentEditor.CreateAsync(document, CancellationToken.None).ConfigureAwait(false);
889? await ImportAdder.AddImportsFromSymbolAnnotationAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false)
890: await ImportAdder.AddImportsFromSyntaxesAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false);
892var formatted = await Formatter.FormatAsync(imported, formattingOptions, CancellationToken.None);
Formatting\FormattingElasticTriviaTests.cs (5)
71var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);
130var formatted = Formatter.Format(newRoot, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString();
133var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString();
136var annotationFormatted = Formatter.Format(newRoot, Formatter.Annotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString();
180var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);
Microsoft.CodeAnalysis.Debugging.Package (2)
Microsoft.CodeAnalysis.EditorFeatures (50)
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (54)
Classification\AbstractClassifierTests.cs (4)
267await service.AddSemanticClassificationsAsync(document, spans, options, result, CancellationToken.None);
268await service.AddEmbeddedLanguageClassificationsAsync(document, spans, options, result, CancellationToken.None);
274var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
278service.AddSyntacticClassifications(root, spans, results, CancellationToken.None);
Formatting\CoreFormatterTestsBase.cs (4)
183var documentSyntax = await ParsedDocument.CreateAsync(document, CancellationToken.None).ConfigureAwait(false);
214var newRootNode = Formatter.Format(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None);
227var result = Formatter.GetFormattedTextChanges(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None);
289var result = Formatter.Format(node, workspace.Services.SolutionServices, options, CancellationToken.None);
SignatureHelp\AbstractSignatureHelpProviderTests.cs (5)
160var items = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None);
177_ = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None);
229Assert.Equal(expectedTestItem.MethodDocumentation, actualSignatureHelpItem.DocumentationFactory(CancellationToken.None).GetFullText());
249var classifiedSpans = actualSignatureHelpItem.DocumentationFactory(CancellationToken.None).ToClassifiedSpans().ToList();
401var items = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None);
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities2 (14)
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (195)
CodeFixes\CodeFixServiceTests.cs (21)
60document, TextSpan.FromBounds(0, 0), new DefaultCodeActionRequestPriorityProvider(), CancellationToken.None);
85_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
112var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
145cancellationToken: CancellationToken.None);
152cancellationToken: CancellationToken.None);
181cancellationToken: CancellationToken.None);
211cancellationToken: CancellationToken.None);
280var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
305document, TextSpan.FromBounds(0, 0), new DefaultCodeActionRequestPriorityProvider(), CancellationToken.None);
752return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
853var txtDocumentCodeFixes = await tuple.codeFixService.GetFixesAsync(txtDocument, TextSpan.FromBounds(0, 1), CancellationToken.None);
861var solution = await codeAction.GetChangedSolutionInternalAsync(txtDocument.Project.Solution, CodeAnalysisProgress.None, CancellationToken.None);
863Assert.Equal("Additional Document", txtDocument.GetTextSynchronously(CancellationToken.None).ToString());
864Assert.Equal($"Additional Document{fixer1.Title}", changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString());
870var logDocumentCodeFixes = await tuple.codeFixService.GetFixesAsync(logDocument, TextSpan.FromBounds(0, 1), CancellationToken.None);
1020var root = await sourceDocument.GetRequiredSyntaxRootAsync(CancellationToken.None);
1030var diagnostics = await analyzerService.ForceAnalyzeProjectAsync(sourceDocument.Project, CancellationToken.None);
1055root = await sourceDocument.GetRequiredSyntaxRootAsync(CancellationToken.None);
1063includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None);
1068var normalPriFixes = await tuple.codeFixService.GetFixesAsync(sourceDocument, testSpan, priorityProvider, CancellationToken.None);
1070var lowPriFixes = await tuple.codeFixService.GetFixesAsync(sourceDocument, testSpan, priorityProvider, CancellationToken.None);
CodeGeneration\CodeGenerationTests.cs (30)
52CancellationToken.None);
86CancellationToken.None);
91var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
93var newRoot = testContext.Service.AddField(root, field, info, CancellationToken.None);
128CancellationToken.None);
173CancellationToken.None);
217CancellationToken.None);
252CancellationToken.None);
298CancellationToken.None);
315var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
317var newSyntax = testContext.Service.AddStatements(oldSyntax, parsedStatements, info, CancellationToken.None);
330var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
333var newMemberSyntax = testContext.Service.AddParameters(oldMemberSyntax, parameterSymbols, info, CancellationToken.None);
366CancellationToken.None);
406CancellationToken.None);
499CancellationToken.None);
528CancellationToken.None);
556var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
558var newNode = codeGenerator.AddAttributes(oldNode, [attributeData], target, info, CancellationToken.None)
575var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
577var newNode = codeGenerator.RemoveAttribute(declarationNode, attribute, info, CancellationToken.None)
597var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None);
601updatedDeclarationNode = codeGenerator.UpdateDeclarationAccessibility(declarationNode, accessibility.Value, info, CancellationToken.None);
605updatedDeclarationNode = codeGenerator.UpdateDeclarationModifiers(declarationNode, modifiers, info, CancellationToken.None);
609updatedDeclarationNode = codeGenerator.UpdateDeclarationType(declarationNode, getType(testContext.SemanticModel), info, CancellationToken.None);
627updatedDeclarationNode = codeGenerator.UpdateDeclarationMembers(declarationNode, allMembers, info, CancellationToken.None);
664testContext.Result = await testContext.Service.AddMembersAsync(solutionContext, (INamedTypeSymbol)destination, members, CancellationToken.None);
668testContext.Result = await testContext.Service.AddNamespaceOrTypeAsync(solutionContext, (INamespaceSymbol)destination, symbol, CancellationToken.None);
976var simplified = Simplifier.ReduceAsync(this.Document, Simplifier.Annotation, simplifierOptions, CancellationToken.None).Result;
977var actual = Formatter.FormatAsync(simplified, Formatter.Annotation, formattingOptions, CancellationToken.None).Result.GetSyntaxRootAsync().Result.ToFullString();
CodeRefactorings\CodeRefactoringServiceTest.cs (13)
51var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
90var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
111var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
174var txtRefactorings = await refactoringService.GetRefactoringsAsync(txtAdditionalDocument, TextSpan.FromBounds(0, 0), CancellationToken.None);
182var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None, CancellationToken.None);
184Assert.Empty(txtAdditionalDocument.GetTextSynchronously(CancellationToken.None).ToString());
185Assert.Equal(refactoring1.Title, changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString());
189var logRefactorings = await refactoringService.GetRefactoringsAsync(logAdditionalDocument, TextSpan.FromBounds(0, 0), CancellationToken.None);
213var editorConfigRefactorings = await refactoringService.GetRefactoringsAsync(editorConfig, TextSpan.FromBounds(0, 0), CancellationToken.None);
221var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None, CancellationToken.None);
223Assert.Empty(editorConfig.GetTextSynchronously(CancellationToken.None).ToString());
224Assert.Equal(refactoring1.Title, changedEditorConfig.GetTextSynchronously(CancellationToken.None).ToString());
228var globalConfigRefactorings = await refactoringService.GetRefactoringsAsync(globalConfig, TextSpan.FromBounds(0, 0), CancellationToken.None);
Completion\FileSystemCompletionHelperTests.cs (13)
60AssertItemsEqual(fsc.GetTestAccessor().GetItems("", CancellationToken.None),
71AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"X:\A\", CancellationToken.None),
76AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"X:\B\", CancellationToken.None),
79AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"Z:\", CancellationToken.None),
83AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"Z:", CancellationToken.None),
86AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\", CancellationToken.None),
117AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None),
153AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None),
179AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\\server\share\", CancellationToken.None),
183AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\\server\share\C\", CancellationToken.None),
218AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None),
227AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"/", CancellationToken.None),
233AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"/B/", CancellationToken.None),
Diagnostics\DiagnosticAnalyzerServiceTests.cs (15)
68includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, CancellationToken.None);
185var diagnostics = await service.ForceAnalyzeProjectAsync(document.Project, CancellationToken.None);
219var diagnostics = await service.ForceAnalyzeProjectAsync(document.Project, CancellationToken.None);
259var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
342var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
391var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
472var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
559var document = isSourceGenerated ? (await project.GetSourceGeneratedDocumentsAsync(CancellationToken.None)).Single() : project.Documents.Single();
594var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
639cancellationToken: CancellationToken.None);
684var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
706CancellationToken.None);
710var expectedText = additionalDocument.GetTextSynchronously(CancellationToken.None).ToString();
774logPerformanceInfo: false, getTelemetryInfo: false, cancellationToken: CancellationToken.None);
805var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);
FindSymbols\SymbolTreeInfoTests.cs (16)
28solution, reference1, checksum: null, CancellationToken.None);
31solution, reference2, checksum: null, CancellationToken.None);
34Assert.Equal(info1.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None));
35Assert.Equal(info2.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None));
48var checksum1 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None);
50solution, reference1, checksum1, CancellationToken.None);
52var checksum2 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None);
54solution, reference2, checksum2, CancellationToken.None);
71var checksum1 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None);
73solution, reference1, checksum1, CancellationToken.None);
76solution, reference2, checksum: null, CancellationToken.None);
80Assert.Equal(info2.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None));
94solution, reference1, checksum: null, CancellationToken.None);
96var checksum2 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None);
98solution, reference2, checksum2, CancellationToken.None);
101Assert.Equal(info1.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None));
MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (6)
91return _metadataAsSourceService.GetGeneratedFileAsync(Workspace, project, symbol, signaturesOnly, MetadataAsSourceOptions.Default, CancellationToken.None);
103var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None);
132var result = await _metadataAsSourceService.GetGeneratedFileAsync(Workspace, project, symbol, signaturesOnly, MetadataAsSourceOptions.Default, CancellationToken.None);
171compilation = await this.DefaultProject.GetRequiredCompilationAsync(CancellationToken.None);
317var syntaxRoot = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);
318var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
Snippets\RoslynLSPSnippetConvertTests.cs (3)
362[], new TextChange(new TextSpan(8, 0), "quux"), triggerLocation: 12, CancellationToken.None).Result;
373[], new TextChange(new TextSpan(4, 4), "bar quux"), triggerLocation: 12, CancellationToken.None).Result;
449var lspSnippetString = await RoslynLSPSnippetConverter.GenerateLSPSnippetAsync(document, cursorPosition!.Value, placeholders, textChange, stringSpan.Start, CancellationToken.None).ConfigureAwait(false);
StackTraceExplorer\StackTraceExplorerTests.cs (13)
25var result = await StackTraceAnalyzer.AnalyzeAsync(inputLine, CancellationToken.None);
32var reparsedResult = await StackTraceAnalyzer.AnalyzeAsync(stackFrame.ToString(), CancellationToken.None);
40var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, stackFrame, StackFrameSymbolPart.Method, CancellationToken.None);
47var root = await doc.GetRequiredSyntaxRootAsync(CancellationToken.None);
49var semanticModel = await doc.GetRequiredSemanticModelAsync(CancellationToken.None);
861var result = await StackTraceAnalyzer.AnalyzeAsync(line, CancellationToken.None);
883var result = await StackTraceAnalyzer.AnalyzeAsync(line, CancellationToken.None);
888var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, parsedFrame, StackFrameSymbolPart.Method, CancellationToken.None);
897var result = await StackTraceAnalyzer.AnalyzeAsync(activityLogException, CancellationToken.None);
913var result = await StackTraceAnalyzer.AnalyzeAsync("at System.String.ToLower()", CancellationToken.None);
918var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, frame, StackFrameSymbolPart.Method, CancellationToken.None);
951var result = await StackTraceAnalyzer.AnalyzeAsync("at Path.To.Component.M() in C:/path/to/Component.razor:line 5", CancellationToken.None);
990var result = await StackTraceAnalyzer.AnalyzeAsync("at Path.To.Component.M() in Component.razor:line 5", CancellationToken.None);
SymbolFinder\SymbolFinderTests.cs (7)
657var results = await SymbolFinder.FindDerivedClassesArrayAsync(firstType, solution, transitive: true, ImmutableHashSet.Create(csProject), CancellationToken.None);
662results = await SymbolFinder.FindDerivedClassesArrayAsync(firstType, solution, transitive: true, ImmutableHashSet.Create(otherProject), CancellationToken.None);
768var interfaceMembers = await SymbolFinder.FindImplementedInterfaceMembersArrayAsync(methodSymbol, solution, CancellationToken.None);
798var implementedMembers = await SymbolFinder.FindImplementedInterfaceMembersArrayAsync(namespaceSymbol, solution, CancellationToken.None);
828var sourceDefinition = await SymbolFinder.FindSourceDefinitionAsync(classInSource, solution, CancellationToken.None);
867.Project.Solution.WithFrozenPartialCompilations(CancellationToken.None);
876var sourceDefinition = await SymbolFinder.FindSourceDefinitionAsync(classInSource, solution, CancellationToken.None);
Microsoft.CodeAnalysis.EditorFeatures2.UnitTests (87)
Classification\ClassificationTests.vb (7)
48ClassificationOptions.Default, CancellationToken.None)
96document, New TextSpan(0, text.Length), ClassificationOptions.Default, includeAdditiveSpans:=False, CancellationToken.None)
157document, New TextSpan(0, text.Length), ClassificationOptions.Default, includeAdditiveSpans:=False, CancellationToken.None)
222ClassificationOptions.Default, CancellationToken.None)
323Dim text = Await wrongDocument.GetTextAsync(CancellationToken.None)
327Await classificationService.AddSyntacticClassificationsAsync(wrongDocument, New TextSpan(0, text.Length), result, CancellationToken.None)
328Await classificationService.AddSemanticClassificationsAsync(wrongDocument, New TextSpan(0, text.Length), options:=Nothing, result, CancellationToken.None)
Diagnostics\DiagnosticServiceTests.vb (11)
65Return Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, CancellationToken.None)
538includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
609includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
808includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
821Dim actualLocation = withDocumentLocationDiagnostic.ToDiagnosticAsync(project, CancellationToken.None).Result.Location
958includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)).
1053includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
2145project, CancellationToken.None)
2155includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
2189Dim root = Await document.GetSyntaxRootAsync(CancellationToken.None)
2242includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)
InlineHints\AbstractInlineHintsTests.vb (2)
32document, span, options, displayOptions, displayAllOverride:=False, CancellationToken.None)
92document, span, options, displayOptions, displayAllOverride:=ephemeral, CancellationToken.None)
Rename\RenameEngineResult.vb (5)
93Dim symbol = RenameUtilities.TryGetRenamableSymbolAsync(document, cursorPosition, CancellationToken.None).Result
137solution, symbol, renameOptions, CancellationToken.None).GetAwaiter().GetResult()
139Return locations.ResolveConflictsAsync(symbol, renameTo, CancellationToken.None).GetAwaiter().GetResult()
145solution, symbol, renameTo, renameOptions, CancellationToken.None).GetAwaiter().GetResult()
274Let spanText = document.GetTextSynchronously(CancellationToken.None).ToString(location.ConflictCheckSpan)
SyncNamespaces\SyncNamespacesServiceTests.vb (5)
43Dim newSolution = Await syncService.SyncNamespacesAsync(ImmutableArray.Create(project), CodeAnalysisProgress.None, CancellationToken.None)
79Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None)
136Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None)
190Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None)
255Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None)
Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (2)
Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (2)
Microsoft.CodeAnalysis.Extensions.Package (2)
Microsoft.CodeAnalysis.ExternalAccess.FSharp (2)
Microsoft.CodeAnalysis.ExternalAccess.OmniSharp (1)
Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler (1)
Microsoft.CodeAnalysis.Features (17)
Microsoft.CodeAnalysis.Features.Test.Utilities (19)
EditAndContinue\EditAndContinueTestVerifier.cs (3)
102CancellationToken.None);
191var result = Analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newProject, lazyOldActiveStatementMap, newActiveStatementSpans, lazyCapabilities, log, CancellationToken.None).Result;
278EditSession.MergePartialEdits(oldProject.GetCompilationAsync().Result!, newProject.GetCompilationAsync().Result!, allEdits, out var mergedEdits, out _, CancellationToken.None);
Snippets\AbstractSnippetProviderTests.cs (9)
36var metadataReferences = await referenceAssemblies.ResolveAsync(LanguageName, CancellationToken.None);
64var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
65var syntaxContext = syntaxContextService.CreateContext(document, semanticModel, snippetRequestPosition, CancellationToken.None);
68var isValidSnippetLocation = snippetProvider.IsValidSnippetLocation(snippetContext, CancellationToken.None);
71var snippetChange = await snippetProvider.GetSnippetChangeAsync(document, snippetRequestPosition, CancellationToken.None);
126var metadataReferences = await referenceAssemblies.ResolveAsync(LanguageName, CancellationToken.None);
141var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
142var syntaxContext = syntaxContextService.CreateContext(document, semanticModel, snippetRequestPosition, CancellationToken.None);
145var isValidSnippetLocation = snippetProvider.IsValidSnippetLocation(snippetContext, CancellationToken.None);
Microsoft.CodeAnalysis.Features.UnitTests (194)
EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (131)
139var sessionId = await service.StartDebuggingSessionAsync(solution, _debuggerService, NullPdbMatchingSourceTextProvider.Instance, captureMatchingDocuments, captureAllDocuments, reportDiagnostics: true, CancellationToken.None);
174var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None);
181diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
218var diagnostics2 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
249var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None);
262diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
292var diagnostics1 = await service.GetDocumentDiagnosticsAsync(generatedDocument, s_noActiveSpans, CancellationToken.None);
372var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None);
457var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None);
533var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None);
591var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None);
757var diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
855var sessionId = await service.StartDebuggingSessionAsync(solution, _debuggerService, NullPdbMatchingSourceTextProvider.Instance, captureMatchingDocuments: openDocumentIds, captureAllMatchingDocuments: false, reportDiagnostics: true, CancellationToken.None);
881var activeStatementMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None);
885var asSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [designTimeOnlyDocumentId], CancellationToken.None);
889Assert.Empty(await service.GetDocumentDiagnosticsAsync(designTimeOnlyDocument2, s_noActiveSpans, CancellationToken.None));
947var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1027var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1075var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1138var diagnostics2 = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None);
1227var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(document2Id), s_noActiveSpans, CancellationToken.None);
1386var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1451var (document, state) = await debuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(solution.GetRequiredDocument(documentId), CancellationToken.None);
1483var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1555var diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1562diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1569diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1587diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1626var docDiagnostics = await service.GetDocumentDiagnosticsAsync(generatedDocument, s_noActiveSpans, CancellationToken.None);
1676var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1691docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1704docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1775var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1818var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1832docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
1893var docDiagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None);
1932Assert.Empty(await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None));
1938Assert.Empty(await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None));
1985var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
2025var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
2092Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2094Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathCommon, CancellationToken.None));
2095Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathB, CancellationToken.None));
2096Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathC, CancellationToken.None));
2097Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: "NonexistentFile.cs", CancellationToken.None));
2109Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2112Assert.True(await EditSession.HasChangesAsync(solution, solution.RemoveProject(projectD.Id), CancellationToken.None));
2120Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2123Assert.False(await EditSession.HasChangesAsync(solution, oldSolution, CancellationToken.None));
2195Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2196Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None));
2199Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, generatedDocument.FilePath, CancellationToken.None));
2205await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None));
2208await EditSession.GetProjectDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), projectDifferences, diagnostics, CancellationToken.None);
2229Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2230Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None));
2236await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None));
2238await EditSession.GetProjectDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), projectDifferences, diagnostics, CancellationToken.None);
2257Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2258Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None));
2261await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None));
2263await EditSession.GetProjectDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), projectDifferences, diagnostics, CancellationToken.None);
2283Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2284Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None));
2289await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None));
2291await EditSession.GetProjectDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), projectDifferences, diagnostics, CancellationToken.None);
2344var generatedDocuments = await project.Solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, CancellationToken.None);
2346var generatedText = generatedDocuments.States.Single().Value.GetTextSynchronously(CancellationToken.None).ToString();
2350var generatorDiagnostics = await solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, CancellationToken.None);
2368Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None));
2371AssertEx.Empty(await EditSession.GetChangedDocumentsAsync(log, oldProject, project, CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None));
2374await EditSession.GetProjectDifferencesAsync(log, oldProject, project, diffences, diagnostics, CancellationToken.None);
2381generatedDocuments = await solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, CancellationToken.None);
2384generatorDiagnostics = await solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, CancellationToken.None);
2444var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentA1.Id, documentB2.Id], CancellationToken.None);
2454var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(documentB2, (_, _, _) => new(trackedActiveSpans), CancellationToken.None);
2459var diagnostics = await service.GetDocumentDiagnosticsAsync(documentB2, s_noActiveSpans, CancellationToken.None);
2500var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2508diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2528diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2537diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2553diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2650var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
2682var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
2849var diagnostics = await service.GetDocumentDiagnosticsAsync(document3, s_noActiveSpans, CancellationToken.None);
2866var (doc, state) = await debuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(currentDocument, CancellationToken.None);
2932var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None);
2989var diagnostics = await service.GetDocumentDiagnosticsAsync(document3, s_noActiveSpans, CancellationToken.None);
3022var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
3357var docDiagnostics = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None);
3448var diagnostics = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None);
3460var result = await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects, s_noActiveSpans, CancellationToken.None);
3504_ = await solution.Projects.Single().GetCompilationAsync(CancellationToken.None);
3561_ = await solution.Projects.Single().GetCompilationAsync(CancellationToken.None);
3858var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None);
3902var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None);
4313var sourceTextV1 = document1.GetTextSynchronously(CancellationToken.None);
4326Assert.True((await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document1.Id], CancellationToken.None)).IsDefault);
4349var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document1.Id], CancellationToken.None);
4358var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document1, (_, _, _) => new(trackedActiveSpans1), CancellationToken.None);
4370currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document2, (_, _, _) => new(trackedActiveSpans2), CancellationToken.None);
4393var sourceTextV1 = await document1.GetTextAsync(CancellationToken.None);
4422var baseSpans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single();
4434var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document2, (_, _, _) => ValueTaskFactory.FromResult(baseSpans), CancellationToken.None);
4470var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document, s_noActiveSpans, CancellationToken.None);
4473var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None);
4479baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None);
4538var baseActiveStatementsMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
4569var spans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [doc1.Id, doc2.Id, docId3, docId4, docId5], CancellationToken.None);
4642var baseActiveStatementMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
4661var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None);
4668baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None);
4826var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None);
4844docDiagnostics = await service.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None);
4962var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single();
5051var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single();
5077spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single();
5086var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None);
5175var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single();
5303CancellationToken.None);
5307var result1 = await encService.EmitSolutionUpdateAsync(sessionId, solution1, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None);
5314var result2 = await encService.EmitSolutionUpdateAsync(sessionId, solution2, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None);
5337await Assert.ThrowsAsync<ObjectDisposedException>(async () => await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None));
5344Assert.Empty(await debuggingSession.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None));
5345Assert.Empty(await debuggingSession.GetAdjustedActiveStatementSpansAsync(document, s_noActiveSpans, CancellationToken.None));
5346Assert.True((await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [], CancellationToken.None)).IsDefault);
EditAndContinue\EditSessionActiveStatementsTests.cs (9)
189var baseActiveStatementsMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
235var oldActiveStatements1 = await baseActiveStatementsMap.GetOldActiveStatementsAsync(analyzer, document1, CancellationToken.None).ConfigureAwait(false);
243var oldActiveStatements2 = await baseActiveStatementsMap.GetOldActiveStatementsAsync(analyzer, document2, CancellationToken.None).ConfigureAwait(false);
353var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
368var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false);
533var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
551var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false);
674var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
703var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false);
EditAndContinue\RemoteEditAndContinueServiceTests.cs (17)
90var syntaxTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
151CancellationToken.None);
162await sessionProxy.BreakStateOrCapabilitiesChangedAsync(inBreakState: true, CancellationToken.None);
164var activeStatement = (await remoteDebuggeeModuleMetadataProvider!.GetActiveStatementsAsync(CancellationToken.None)).Single();
169var availability = await remoteDebuggeeModuleMetadataProvider!.GetAvailabilityAsync(moduleId1, CancellationToken.None);
201var syntaxTree = solution.GetRequiredDocument(documentId).GetSyntaxTreeSynchronously(CancellationToken.None)!;
222var results = await sessionProxy.EmitSolutionUpdateAsync(localWorkspace.CurrentSolution, runningProjects1, activeStatementSpanProvider, CancellationToken.None);
247await sessionProxy.CommitSolutionUpdateAsync(CancellationToken.None);
253await sessionProxy.DiscardSolutionUpdateAsync(CancellationToken.None);
266var baseActiveSpans = await sessionProxy.GetBaseActiveStatementSpansAsync(localWorkspace.CurrentSolution, [documentId, inProcOnlyDocumentId], CancellationToken.None);
274AssertEx.Equal(activeSpans1, activeStatementSpanProvider(documentId, "test.cs", CancellationToken.None).AsTask().Result);
278Assert.Empty(await sessionProxy.GetAdjustedActiveStatementSpansAsync(inProcOnlyDocument, activeStatementSpanProvider, CancellationToken.None));
280var documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document, activeStatementSpanProvider, CancellationToken.None);
287documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document, activeStatementSpanProvider, CancellationToken.None);
294Assert.Empty(await proxy.GetDocumentDiagnosticsAsync(inProcOnlyDocument, activeStatementSpanProvider, CancellationToken.None));
295Assert.Equal(diagnostic.GetMessage(), (await proxy.GetDocumentDiagnosticsAsync(document, activeStatementSpanProvider, CancellationToken.None)).Single().Message);
299await sessionProxy.EndDebuggingSessionAsync(CancellationToken.None);
EditAndContinue\UnitTestingHotReloadServiceTests.cs (4)
48await hotReload.StartSessionAsync(solution, ["Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"], CancellationToken.None);
61var result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None);
68result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None);
78result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None);
FindUsages\DefinitionItemFactoryTests.cs (29)
140var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(a, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
176var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
218var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
254var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
296var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
338var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(n, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
391var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(n, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
445var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
485var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
525var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
567var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
625var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
671var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
711var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(tuple, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
773var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(tuple, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
829var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(type, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
883var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(type, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
943var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
987var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1042var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1094var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1158var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(g, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1215var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(g, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1270var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1350var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1409var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1461var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(f, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1528var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(x, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
1599var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(r, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);
Microsoft.CodeAnalysis.InteractiveHost (9)
Microsoft.CodeAnalysis.LanguageServer (16)
Microsoft.CodeAnalysis.LanguageServer.Protocol (3)
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (214)
CodeLens\AbstractCodeLensTests.cs (4)
30var actualCodeLenses = await testLspServer.ExecuteRequestAsync<LSP.CodeLensParams, LSP.CodeLens[]?>(LSP.Methods.TextDocumentCodeLensName, codeLensParams, CancellationToken.None);
48var resolvedCodeLens = await testLspServer.ExecuteRequestAsync<LSP.CodeLens, LSP.CodeLens>(LSP.Methods.CodeLensResolveName, matchingCodeLens, CancellationToken.None);
65var actualCodeLenses = await testLspServer.ExecuteRequestAsync<LSP.CodeLensParams, LSP.CodeLens[]?>(LSP.Methods.TextDocumentCodeLensName, codeLensParams, CancellationToken.None);
88var actualCodeLenses = await testLspServer.ExecuteRequestAsync<LSP.CodeLensParams, LSP.CodeLens[]?>(LSP.Methods.TextDocumentCodeLensName, codeLensParams, CancellationToken.None);
Completion\CompletionFeaturesTests.cs (28)
94var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
128var completionResult = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
150var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, actualItem, CancellationToken.None).ConfigureAwait(false);
215var completionResult = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
237var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, actualItem, CancellationToken.None).ConfigureAwait(false);
279var completionResult = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
300var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, actualItem, CancellationToken.None).ConfigureAwait(false);
343var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
366results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
421var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
471var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
540var completionResult = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
562var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, actualItem, CancellationToken.None).ConfigureAwait(false);
665var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
709var completionResult = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
725var resolvedItem1 = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, itemFromNS1, CancellationToken.None).ConfigureAwait(false);
733var resolvedItem2 = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, itemFromNS2, CancellationToken.None).ConfigureAwait(false);
772var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
806var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
821results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
859var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
875results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None).ConfigureAwait(false);
975var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
979var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, item, CancellationToken.None).ConfigureAwait(false);
1045var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
1052var resolvedItem = await testLspServer.ExecuteRequestAsync<LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, item, CancellationToken.None).ConfigureAwait(false);
1103var results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
1118results = await testLspServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);
HandlerTests.cs (12)
48var response = await server.ExecuteRequestAsync<TestRequestTypeOne, string>(TestDocumentHandler.MethodName, request, CancellationToken.None);
57var response = await server.ExecuteRequest0Async<string>(TestRequestHandlerWithNoParams.MethodName, CancellationToken.None);
95var response = await server.ExecuteRequestAsync<TestRequestTypeOne, string>(TestDocumentHandler.MethodName, request, CancellationToken.None);
108var response = await server.ExecuteRequestAsync<TestRequestTypeTwo, string>(TestDocumentHandler.MethodName, request, CancellationToken.None);
123await Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(async () => await server.ExecuteRequestAsync<TestRequestTypeThree, string>(TestNonMutatingDocumentHandler.MethodName, request, CancellationToken.None));
133await Assert.ThrowsAnyAsync<Exception>(async () => await server.ExecuteRequestAsync<TestRequestTypeThree, string>(TestDocumentHandler.MethodName, request, CancellationToken.None));
160=> await server.ExecuteRequestAsync<TestRequestWithDocument, TestConfigurableResponse>(TestConfigurableDocumentHandler.MethodName, request, CancellationToken.None));
188=> await server.ExecuteRequestAsync<TestRequestWithDocument, TestConfigurableResponse>(TestConfigurableDocumentHandler.MethodName, request, CancellationToken.None));
216=> await server.ExecuteRequestAsync<TestRequestWithDocument, TestConfigurableResponse>(TestConfigurableDocumentHandler.MethodName, request, CancellationToken.None));
246=> await server.ExecuteRequestAsync<TestRequestWithDocument, TestConfigurableResponse>(TestConfigurableDocumentHandler.MethodName, request, CancellationToken.None));
274=> await server.ExecuteRequestAsync<TestRequestWithDocument, TestConfigurableResponse>(TestConfigurableDocumentHandler.MethodName, request, CancellationToken.None));
293await Assert.ThrowsAnyAsync<Exception>(async () => await testLspServer.ExecuteRequestAsync<TestRequestTypeOne, string>(TestDocumentHandler.MethodName, request, CancellationToken.None)).ConfigureAwait(false);
Initialize\LocaleTests.cs (5)
32var result = await testLspServer.ExecuteRequestAsync<Request, Response>(LocaleTestHandler.MethodName, new Request(), CancellationToken.None);
49var resultOne = await testLspServerOne.ExecuteRequestAsync<Request, Response>(LocaleTestHandler.MethodName, new Request(), CancellationToken.None);
50var resultTwo = await testLspServerTwo.ExecuteRequestAsync<Request, Response>(LocaleTestHandler.MethodName, new Request(), CancellationToken.None);
64var result = await testLspServer.ExecuteRequestAsync<Request, Response>(LocaleTestHandler.MethodName, new Request(), CancellationToken.None);
77var result = await testLspServer.ExecuteRequestAsync<Request, Response>(LocaleTestHandler.MethodName, new Request(), CancellationToken.None);
InlayHint\CSharpInlayHintTests.cs (5)
123var actualInlayHints = await testLspServer.ExecuteRequestAsync<LSP.InlayHintParams, LSP.InlayHint[]?>(LSP.Methods.TextDocumentInlayHintName, inlayHintParams, CancellationToken.None);
135await testLspServer.ExecuteRequestAsync<LSP.InlayHintParams, LSP.InlayHint[]?>(LSP.Methods.TextDocumentInlayHintName, inlayHintParams, CancellationToken.None);
136await testLspServer.ExecuteRequestAsync<LSP.InlayHintParams, LSP.InlayHint[]?>(LSP.Methods.TextDocumentInlayHintName, inlayHintParams, CancellationToken.None);
137var lastInlayHints = await testLspServer.ExecuteRequestAsync<LSP.InlayHintParams, LSP.InlayHint[]?>(LSP.Methods.TextDocumentInlayHintName, inlayHintParams, CancellationToken.None);
145var firstResolvedHint = await testLspServer.ExecuteRequestAsync<LSP.InlayHint, LSP.InlayHint>(LSP.Methods.InlayHintResolveName, firstInlayHint, CancellationToken.None);
Miscellaneous\LspMiscellaneousFilesWorkspaceTests.cs (7)
64var miscWorkspaceText = await GetMiscellaneousDocument(testLspServer)!.GetTextAsync(CancellationToken.None);
82miscWorkspaceText = await GetMiscellaneousDocument(testLspServer)!.GetTextAsync(CancellationToken.None);
159var (miscWorkspace, _, miscDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = looseFileUri }, CancellationToken.None);
302}), CancellationToken.None);
320var (lspWorkspace, _, _) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = fileUri }, CancellationToken.None);
326var (lspWorkspace, _, _) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = fileUri }, CancellationToken.None).ConfigureAwait(false);
343CreateTextDocumentPositionParams(caret), CancellationToken.None);
Rename\RenameTests.cs (3)
223var results = await RenameHandler.GetRenameEditAsync(document, renamePosition, renameValue, includeSourceGenerated: true, CancellationToken.None);
266var results = await RenameHandler.GetRenameEditAsync(document, renamePosition, renameValue, includeSourceGenerated: true, CancellationToken.None);
280return await testLspServer.ExecuteRequestAsync<LSP.RenameParams, LSP.WorkspaceEdit>(LSP.Methods.TextDocumentRenameName, renameParams, CancellationToken.None);
SemanticTokens\SemanticTokensRangeTests.cs (6)
130document, spans, isVS, options, CancellationToken.None);
186document, spans, isVS, options, CancellationToken.None);
238document, spans, isVS, options, CancellationToken.None);
299document, spans, isVS, options, CancellationToken.None);
382document, spans, isVS, options, CancellationToken.None);
493document, spans: [text.Lines.GetLinePositionSpan(new(0, text.Length))], isVS, options: options, cancellationToken: CancellationToken.None);
UriTests.cs (23)
53var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = looseFileUri }, CancellationToken.None);
79var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = looseFileUri }, CancellationToken.None);
111var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = expectedDocumentUri }, CancellationToken.None);
122var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = lowercaseUri }, CancellationToken.None);
149var (workspace, _, fileDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = fileDocumentUri }, CancellationToken.None);
156var (gitWorkspace, _, gitDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = gitDocumentUri }, CancellationToken.None);
185var (workspace, _, lspDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = unencodedUri }, CancellationToken.None).ConfigureAwait(false);
189var originalText = await lspDocument.GetTextAsync(CancellationToken.None);
196new CustomResolveParams(new LSP.TextDocumentIdentifier { DocumentUri = encodedUri }), CancellationToken.None);
200var (encodedWorkspace, _, encodedDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = encodedUri }, CancellationToken.None).ConfigureAwait(false);
204var encodedText = await encodedDocument.GetTextAsync(CancellationToken.None);
233var (workspace, _, lspDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = upperCaseUri }, CancellationToken.None).ConfigureAwait(false);
237var originalText = await lspDocument.GetTextAsync(CancellationToken.None);
242new CustomResolveParams(new LSP.TextDocumentIdentifier { DocumentUri = lowerCaseUri }), CancellationToken.None);
246var (lowerCaseWorkspace, _, lowerCaseDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = lowerCaseUri }, CancellationToken.None).ConfigureAwait(false);
250var lowerCaseText = await lowerCaseDocument.GetTextAsync(CancellationToken.None);
279var (workspace, _, lspDocument) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = upperCaseUri }, CancellationToken.None).ConfigureAwait(false);
283var originalText = await lspDocument.GetTextAsync(CancellationToken.None);
289new CustomResolveParams(new LSP.TextDocumentIdentifier { DocumentUri = lowerCaseUri }), CancellationToken.None));
303var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = looseFileUri }, CancellationToken.None);
315new CustomResolveParams(new LSP.TextDocumentIdentifier { DocumentUri = looseFileUri }), CancellationToken.None));
345new CustomResolveParams(new LSP.TextDocumentIdentifier { DocumentUri = invalidUri }), CancellationToken.None);
351var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(new LSP.TextDocumentIdentifier { DocumentUri = invalidUri }, CancellationToken.None);
Workspaces\LspWorkspaceManagerTests.cs (33)
40Assert.Equal("LSP text", (await lspDocument.GetTextAsync(CancellationToken.None)).ToString());
46Assert.Equal("More textLSP text", (await lspDocument.GetTextAsync(CancellationToken.None)).ToString());
66var firstDocumentInitialVersion = await firstDocument.GetSyntaxVersionAsync(CancellationToken.None);
67var secondDocumentInitialVersion = await secondDocument.GetSyntaxVersionAsync(CancellationToken.None);
96Assert.NotEqual(firstDocumentInitialVersion, await firstDocumentWithChange.GetSyntaxVersionAsync(CancellationToken.None));
97Assert.Equal($"Some more text{markupOne}", (await firstDocumentWithChange.GetTextAsync(CancellationToken.None)).ToString());
100Assert.Equal(secondDocumentInitialVersion, await secondDocumentUnchanged.GetSyntaxVersionAsync(CancellationToken.None));
127Assert.Equal("LSP text", (await openedDocument.GetTextAsync(CancellationToken.None)).ToString());
165Assert.Equal(markup, (await openedDocument.GetTextAsync(CancellationToken.None)).ToString());
198Assert.Equal("LSP text", (await openedDocument.GetTextAsync(CancellationToken.None)).ToString());
258Assert.Equal("LSP text", (await miscDocument.GetTextAsync(CancellationToken.None)).ToString());
264var miscText = await miscDocument.GetTextAsync(CancellationToken.None);
276var documentText = await document.GetTextAsync(CancellationToken.None);
402var changedFirstDocumentText = await changedFirstDocument.GetTextAsync(CancellationToken.None);
403var firstDocumentText = await firstDocument.GetTextAsync(CancellationToken.None);
498Assert.Equal("Server one text", (await documentServerTwo.GetTextAsync(CancellationToken.None)).ToString());
502Assert.Equal("Original text", (await documentServerTwo.GetTextAsync(CancellationToken.None)).ToString());
534Assert.Equal("Text", (await lspDocument.GetTextAsync(CancellationToken.None)).ToString());
559Assert.Equal("Text", (await document1.GetTextAsync(CancellationToken.None)).ToString());
569(await document1.GetTextAsync(CancellationToken.None)).ToString(),
578Assert.Equal("Text", (await document1.GetTextAsync(CancellationToken.None)).ToString());
582(await document1.GetTextAsync(CancellationToken.None)).ToString(),
596Assert.Equal("Text", (await document1.GetTextAsync(CancellationToken.None)).ToString());
617Assert.Equal("Text", (await document.GetTextAsync(CancellationToken.None)).ToString());
631Assert.Equal("Text", (await document.GetTextAsync(CancellationToken.None)).ToString());
656var originalSourceText = await originalDocument.GetTextAsync(CancellationToken.None);
657var originalRoot = await originalDocument.GetRequiredSyntaxRootAsync(CancellationToken.None);
667var newSourceText = await newDocument.GetTextAsync(CancellationToken.None);
668var newRoot = await newDocument.GetRequiredSyntaxRootAsync(CancellationToken.None);
754Assert.Equal(generatorText, (await sourceGeneratedDocument.GetTextAsync(CancellationToken.None)).ToString());
765Assert.Equal(openText, (await lspDocument.GetTextAsync(CancellationToken.None)).ToString());
776var (workspace, _, document) = await testLspServer.GetManager().GetLspDocumentInfoAsync(CreateTextDocumentIdentifier(uri), CancellationToken.None).ConfigureAwait(false);
782return testLspServer.GetManager().GetLspSolutionInfoAsync(CancellationToken.None);
Workspaces\SourceGeneratedDocumentTests.cs (15)
33new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
49new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
74new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
97CreateTextDocumentPositionParams(location), CancellationToken.None);
118new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
134new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
141new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: text.ResultId), CancellationToken.None);
163new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
176new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: text.ResultId), CancellationToken.None);
210new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
220new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: text.ResultId), CancellationToken.None);
238new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
246new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: text.ResultId), CancellationToken.None);
264new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: null), CancellationToken.None);
276new SourceGeneratorGetTextParams(new LSP.TextDocumentIdentifier { DocumentUri = sourceGeneratorDocumentUri }, ResultId: text.ResultId), CancellationToken.None);
Microsoft.CodeAnalysis.LanguageServer.UnitTests (21)
Utilities\LspClientExtensions.cs (4)
13=> lspClient.ExecuteRequestAsync<InitializedParams, object>(Methods.InitializedName, new InitializedParams(), CancellationToken.None);
17return await lspClient.ExecuteRequestAsync<InitializeParams, InitializeResult>(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None);
27var result = await lspClient.ExecuteRequestAsync<CodeActionParams, CodeAction[]>(Methods.TextDocumentCodeActionName, codeActionParams, CancellationToken.None);
36var result = (VSInternalCodeAction?)await lspClient.ExecuteRequestAsync<CodeAction, CodeAction>(Methods.CodeActionResolveName, unresolvedCodeAction, CancellationToken.None);
VirtualProjectXmlProviderTests.cs (5)
71var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>(), CancellationToken.None);
96var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, logger, CancellationToken.None);
128var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>(), CancellationToken.None);
153var content = await projectProvider.GetVirtualProjectContentAsync(Path.Combine(tempDir.Path, "BAD"), LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>(), CancellationToken.None);
179var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>(), CancellationToken.None);
Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (23)
Microsoft.CodeAnalysis.PooledObjects.Package (2)
Microsoft.CodeAnalysis.PublicApiAnalyzers (23)
Microsoft.CodeAnalysis.Rebuild.UnitTests (1)
Microsoft.CodeAnalysis.Remote.ServiceHub (12)
Host\TestUtils.cs (6)
50var assetMapFromNewSolution = await solutionFromScratch.GetAssetMapAsync(projectConeId, CancellationToken.None).ConfigureAwait(false);
51var assetMapFromIncrementalSolution = await incrementalSolutionBuilt.GetAssetMapAsync(projectConeId, CancellationToken.None).ConfigureAwait(false);
108AssetPath.FullLookupForTesting, checksum, CancellationToken.None).ConfigureAwait(false)));
119AssetPathKind.SolutionCompilationStateChecksums, solutionChecksum, CancellationToken.None).ConfigureAwait(false);
121AssetPathKind.SolutionStateChecksums, solutionCompilationChecksums.SolutionState, CancellationToken.None).ConfigureAwait(false);
129assetPath: projectId, projectChecksum, CancellationToken.None).ConfigureAwait(false);
Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests (2)
TelemetryLoggerTests.cs (2)
67logger.LogBlockStart(FunctionId.Debugging_EncSession_EditSession_EmitDeltaErrorId, KeyValueLogMessage.Create(p => p.Add("test", "start"), logLevel: LogLevel.Information), blockId: 1, CancellationToken.None);
72logger.LogBlockEnd(FunctionId.Debugging_EncSession_EditSession_EmitDeltaErrorId, KeyValueLogMessage.Create(p => p.Add("test", "end")), blockId: 1, delta: 100, CancellationToken.None);
Microsoft.CodeAnalysis.Remote.Workspaces (1)
Microsoft.CodeAnalysis.ResxSourceGenerator (23)
Microsoft.CodeAnalysis.Test.Utilities (4)
Microsoft.CodeAnalysis.Threading.Package (2)
Microsoft.CodeAnalysis.UnitTests (3)
Microsoft.CodeAnalysis.VisualBasic (9)
Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (4)
CommandLineTests.vb (4)
136Assert.True(syntaxTreeOptions.TryGetDiagnosticValue(tree, "BC42024", CancellationToken.None, report))
138Assert.True(syntaxTreeOptions.TryGetDiagnosticValue(tree, "warning01", CancellationToken.None, report))
140Assert.True(syntaxTreeOptions.TryGetDiagnosticValue(tree, "warning03", CancellationToken.None, report))
142Assert.False(syntaxTreeOptions.TryGetDiagnosticValue(tree, "warning02", CancellationToken.None, report))
Microsoft.CodeAnalysis.VisualBasic.EditorFeatures (3)
Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests (1)
Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler (2)
Microsoft.CodeAnalysis.VisualBasic.Features (2)
Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests (2)
Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (7)
Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (1)
Microsoft.CodeAnalysis.VisualBasic.Workspaces (2)
Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (19)
CodeGeneration\AddImportsTests.vb (5)
96Await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, addImportOptions, CancellationToken.None),
97Await ImportAdder.AddImportsFromSyntaxesAsync(doc, addImportOptions, CancellationToken.None))
100Dim formatted = Await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None)
106Dim reduced = Await Simplifier.ReduceAsync(imported, simplifierOptions, CancellationToken.None)
107Dim formatted = Await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None)
Formatting\FormattingTests.vb (5)
3020Dim result = Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None)
3027Dim result2 = Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None)
3787Dim result = Formatter.Format(root, goo, workspace.Services.SolutionServices, VisualBasicSyntaxFormattingOptions.Default, CancellationToken.None).ToString()
4208document = Await Formatter.FormatAsync(newDocument, VisualBasicSyntaxFormattingOptions.Default, CancellationToken.None)
4604Dim formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None)
Formatting\VisualBasicFormattingTestBase.vb (3)
66Dim changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), workspace.Services.SolutionServices, options, CancellationToken.None)
69changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), (Await syntaxTree.GetRootAsync()).FullSpan, workspace.Services.SolutionServices, options, CancellationToken.None)
75changes = Formatter.GetFormattedTextChanges(Await syntaxTree.GetRootAsync(), spans, workspace.Services.SolutionServices, options, CancellationToken.None)
Microsoft.CodeAnalysis.Workspaces (74)
Microsoft.CodeAnalysis.Workspaces.MSBuild (16)
MSBuild\MSBuildWorkspace.cs (15)
355var buildHost = _applyChangesBuildHostProcessManager.GetBuildHostWithFallbackAsync(projectPath, CancellationToken.None).Result;
356_applyChangesProjectFile = buildHost.LoadProjectFileAsync(projectPath, languageName, CancellationToken.None).Result;
373_applyChangesProjectFile.SaveAsync(CancellationToken.None).Wait();
477_applyChangesProjectFile.AddDocumentAsync(relativePath, logicalPath: null, CancellationToken.None).Wait();
518_applyChangesProjectFile.RemoveDocumentAsync(document.FilePath, CancellationToken.None).Wait();
589_applyChangesProjectFile.AddMetadataReferenceAsync(identity.GetDisplayName(), metadataReference.Properties.Aliases, hintPath: null, CancellationToken.None).Wait();
595_applyChangesProjectFile.AddMetadataReferenceAsync(fileName, metadataReference.Properties.Aliases, hintPath: null, CancellationToken.None).Wait();
601_applyChangesProjectFile.AddMetadataReferenceAsync(fileName, metadataReference.Properties.Aliases, relativePath, CancellationToken.None).Wait();
621_applyChangesProjectFile.RemoveMetadataReferenceAsync(identity.Name, identity.GetDisplayName(), peRef.FilePath, CancellationToken.None).Wait();
640var compilation = project.GetCompilationAsync(CancellationToken.None).WaitAndGetResult_CanCallOnBackground(CancellationToken.None);
659_applyChangesProjectFile.AddProjectReferenceAsync(project.Name, reference, CancellationToken.None).Wait();
672_applyChangesProjectFile.RemoveProjectReferenceAsync(project.Name, project.FilePath, CancellationToken.None).Wait();
684_applyChangesProjectFile.AddAnalyzerReferenceAsync(fileRef.FullPath, CancellationToken.None).Wait();
696_applyChangesProjectFile.RemoveAnalyzerReferenceAsync(fileRef.FullPath, CancellationToken.None).Wait();
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (4)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (34)
RpcTests.cs (13)
73var result = await rpcPair.Client.InvokeAsync<string>(targetObject: 0, nameof(ObjectWithHelloMethod.Hello), [s], CancellationToken.None);
84var result = await rpcPair.Client.InvokeAsync<int>(targetObject: 0, nameof(ObjectWithAddMethod.Add), [1, 1], CancellationToken.None);
97var result = await rpcPair.Client.InvokeNullableAsync<string>(targetObject: 0, nameof(ObjectWithNullableHelloMethod.TryHello), ["World"], CancellationToken.None);
101result = await rpcPair.Client.InvokeNullableAsync<string>(targetObject: 0, nameof(ObjectWithNullableHelloMethod.TryHello), [null], CancellationToken.None);
113await rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithVoidMethod.SetMessage), ["Hello, World!"], CancellationToken.None);
125var result = await rpcPair.Client.InvokeAsync<string>(targetObject: 0, nameof(ObjectWithAsyncHelloMethods.HelloAsync), ["World"], CancellationToken.None);
128result = await rpcPair.Client.InvokeAsync<string>(targetObject: 0, nameof(ObjectWithAsyncHelloMethods.HelloWithCancellationAsync), ["World"], CancellationToken.None);
140var call1 = rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithRealAsyncMethod.WaitAsync), [], CancellationToken.None);
147var call2 = rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithRealAsyncMethod.WaitAsync), [], CancellationToken.None);
170var call1 = rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithRealAsyncMethod.WaitAsync), [], CancellationToken.None);
177var call2 = rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithRealAsyncMethod.WaitAsync), [], CancellationToken.None);
199var exception = await Assert.ThrowsAsync<RemoteInvocationException>(() => rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithThrowingMethod.ThrowException), [], CancellationToken.None));
227await rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithMethodThatShutsDownServer.Shutdown), [], CancellationToken.None);
Microsoft.CodeAnalysis.Workspaces.Test.Utilities (5)
Microsoft.CodeAnalysis.Workspaces.UnitTests (352)
CodeCleanup\CodeCleanupTests.cs (14)
41var cleanDocument = await CodeCleaner.CleanupAsync(document, [], await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
50var cleanDocument = await CodeCleaner.CleanupAsync(document, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
60var cleanDocument = await CodeCleaner.CleanupAsync(document, root.FullSpan, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
70var cleanDocument = await CodeCleaner.CleanupAsync(document, [root.FullSpan], await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
97var cleanDocument = await CodeCleaner.CleanupAsync(document, [], await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
109var cleanDocument = await CodeCleaner.CleanupAsync(document, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
122var cleanDocument = await CodeCleaner.CleanupAsync(document, root.FullSpan, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
135var cleanDocument = await CodeCleaner.CleanupAsync(document, [root.FullSpan], await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
147var cleanDocument = await CodeCleaner.CleanupAsync(document, annotation, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
162var cleanDocument = await CodeCleaner.CleanupAsync(document, annotation, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
313var newSemanticModel = await document.ReuseExistingSpeculativeModelAsync(accessor.Statements[0], CancellationToken.None);
323newSemanticModel = await document.ReuseExistingSpeculativeModelAsync(accessor.Statements[0], CancellationToken.None);
327var cleanDocument = await CodeCleaner.CleanupAsync(document, await document.GetCodeCleanupOptionsAsync(CancellationToken.None));
409await document.GetCodeCleanupOptionsAsync(CancellationToken.None),
Formatter\FormatterTests.cs (8)
55var formattedDocument = await Formatter.FormatAsync(document, spans: null, options: null, CancellationToken.None);
92var formattedDocument = await Formatter.FormatAsync(document, spans: null, options, CancellationToken.None);
121ValidateCSharpOptions((CSharpSyntaxFormattingOptions)(await Formatter.GetFormattingOptionsAsync(csDocument, updatedOptions, CancellationToken.None)).Syntax!);
122ValidateVisualBasicOptions((VisualBasicSyntaxFormattingOptions)(await Formatter.GetFormattingOptionsAsync(vbDocument, updatedOptions, CancellationToken.None)).Syntax!);
131ValidateCSharpOptions((CSharpSyntaxFormattingOptions)(await Formatter.GetFormattingOptionsAsync(csDocumentWithUpdatedOptions, optionSet: null, CancellationToken.None)).Syntax!);
132ValidateVisualBasicOptions((VisualBasicSyntaxFormattingOptions)(await Formatter.GetFormattingOptionsAsync(vbDocumentWithUpdatedOptions, optionSet: null, CancellationToken.None)).Syntax!);
133ValidateOrganizeImportsOptions(await Formatter.GetOrganizeImportsOptionsAsync(csDocumentWithUpdatedOptions, CancellationToken.None));
134ValidateOrganizeImportsOptions(await Formatter.GetOrganizeImportsOptionsAsync(vbDocumentWithUpdatedOptions, CancellationToken.None));
SemanticModelReuse\SemanticModelReuseTests.cs (53)
42var model = await document.ReuseExistingSpeculativeModelAsync(null, CancellationToken.None);
54var model1 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
55var model2 = await document.ReuseExistingSpeculativeModelAsync(null, CancellationToken.None);
68var model1 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
69var model2 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
88var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
94var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
105var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
111var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
117var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
128var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
134var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
140var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
151var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
157var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
163var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
174var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
180var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
186var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
197var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
203var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
209var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
221var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
227var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
231CSharpSyntaxContext.CreateContext(document2, model2, source.IndexOf("void"), CancellationToken.None);
248var model1 = await document1.ReuseExistingSpeculativeModelAsync(source1.IndexOf("return"), CancellationToken.None);
254var model2 = await document2.ReuseExistingSpeculativeModelAsync(source2.IndexOf("{ return"), CancellationToken.None);
258CSharpSyntaxContext.CreateContext(document2, model2, source2.IndexOf("{ return"), CancellationToken.None);
271var model = await document.ReuseExistingSpeculativeModelAsync(null, CancellationToken.None);
289var model1 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
290var model2 = await document.ReuseExistingSpeculativeModelAsync(null, CancellationToken.None);
309var model1 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
310var model2 = await document.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
335var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
347var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
364var model1 = await document1.ReuseExistingSpeculativeModelAsync(source1.IndexOf("return"), CancellationToken.None);
377var model2 = await document2.ReuseExistingSpeculativeModelAsync(source2.IndexOf("return"), CancellationToken.None);
389var model3 = await document3.ReuseExistingSpeculativeModelAsync(source2.IndexOf("return"), CancellationToken.None);
406var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
418var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
430var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
449var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
463var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
477var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
496var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
510var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
524var model3 = await document3.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
542var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
554var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
558VisualBasicSyntaxContext.CreateContext(document2, model2, source.IndexOf("sub"), CancellationToken.None);
575var model1 = await document1.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
588var model2 = await document2.ReuseExistingSpeculativeModelAsync(source.IndexOf("return"), CancellationToken.None);
592VisualBasicSyntaxContext.CreateContext(document2, model2, source.IndexOf("return"), CancellationToken.None);
SolutionTests\SolutionTests.cs (126)
338Assert.Throws<ArgumentException>(() => provider.TryGetDiagnosticValue(tree, "CA1234", CancellationToken.None, out _));
439var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
440var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
462root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
463root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
483root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
484root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
527var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
528var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
550root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
551root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
571root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
572root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
606var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
607var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
633root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
634root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
657root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
658root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
692var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
693var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
716root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
717root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
737root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
738root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
769var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
770var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
792root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
793root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
813root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
814root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
857var root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
858var root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
879root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
880root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
902root1 = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
903root2 = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
1013Assert.Equal("new text", newSolution1.GetDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString());
1035Assert.Equal("new text", newSolution1.GetAdditionalDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString());
1057Assert.Equal("new text", newSolution1.GetAnalyzerConfigDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString());
1230var newText1 = newDocument1.GetTextSynchronously(CancellationToken.None);
1239var newText3 = newDocument3.GetTextSynchronously(CancellationToken.None);
1243Assert.Equal("class NewD3;", newDocument3.GetTextSynchronously(CancellationToken.None).ToString());
1251var newAddText1 = newAddDocument1.GetTextSynchronously(CancellationToken.None);
1260var newAddText3 = newAddDocument3.GetTextSynchronously(CancellationToken.None);
1264Assert.Equal("new text3", newAddDocument3.GetTextSynchronously(CancellationToken.None).ToString());
1272var newConfigText1 = newConfigDocument1.GetTextSynchronously(CancellationToken.None);
1281var newConfigText3 = newConfigDocument3.GetTextSynchronously(CancellationToken.None);
1285Assert.Equal("#new empty3", newConfigDocument3.GetTextSynchronously(CancellationToken.None).ToString());
1789var oldTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1795var newTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1827var oldTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1842var newTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1865var oldTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1867var newTree = await newDocument.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1884var oldTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1886var newTree = await newDocument.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1903var oldTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
1905var newTree = await newDocument.GetRequiredSyntaxTreeAsync(CancellationToken.None);
2333var sourcePathOptions = project2.State.GetAnalyzerOptionsForPath(Path.Combine(s_projectDir, "x.cs"), CancellationToken.None);
2344sourcePathOptions = project2.State.GetAnalyzerOptionsForPath(Path.Combine(s_projectDir, "subfolder", "x.cs"), CancellationToken.None);
2892referenced, solution.GetProjectState(project.Id), includeCrossLanguage: true, CancellationToken.None);
2963await solution.GetProject(projectIds[0]).GetCompilationAsync(CancellationToken.None);
2964await solution.GetProject(projectIds[2]).GetCompilationAsync(CancellationToken.None);
2979var namespacesAndTypes = assemblyReference.GlobalNamespace.GetAllNamespacesAndTypes(CancellationToken.None);
3193var newRoot = await Formatter.FormatAsync(document, CSharpSyntaxFormattingOptions.Default, CancellationToken.None).Result.GetSyntaxRootAsync();
3259var syntaxRoot = await document.GetSyntaxRootAsync(CancellationToken.None);
3275var tree = await documentWithAttribute.GetSyntaxTreeAsync(CancellationToken.None);
3276var root = await documentWithAttribute.GetRequiredSyntaxRootAsync(CancellationToken.None);
3461var tree = CSharp.SyntaxFactory.ParseSyntaxTree("public class C {}").GetRoot(CancellationToken.None);
3951var exceptionMessage = await doc.State.GetFailedToLoadExceptionMessageAsync(CancellationToken.None).ConfigureAwait(false);
3957var compilation = await doc.Project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false);
4049Assert.False(await project.HasSuccessfullyLoadedAsync(CancellationToken.None));
4080Assert.True(await project1.HasSuccessfullyLoadedAsync(CancellationToken.None));
4081Assert.True(await project2.HasSuccessfullyLoadedAsync(CancellationToken.None));
4109Assert.True(await project1.HasSuccessfullyLoadedAsync(CancellationToken.None));
4110Assert.False(await project2.HasSuccessfullyLoadedAsync(CancellationToken.None));
4122var frozenDocument = documentToFreeze.WithFrozenPartialSemantics(CancellationToken.None);
4147var frozenDocument = documentToFreeze.WithFrozenPartialSemantics(CancellationToken.None);
4163var frozenDocument2 = frozenDocument.WithFrozenPartialSemantics(CancellationToken.None);
4182var frozenDocument = documentToFreezeChanged.WithFrozenPartialSemantics(CancellationToken.None);
4227var frozenDocument = documentToFreezeChanged.WithFrozenPartialSemantics(CancellationToken.None);
4288var frozenSolution = document.WithFrozenPartialSemantics(CancellationToken.None).Project.Solution;
4290Assert.True(await frozenSolution.GetProject(project1.Id).HasSuccessfullyLoadedAsync(CancellationToken.None));
4291Assert.True(await frozenSolution.GetProject(project2.Id).HasSuccessfullyLoadedAsync(CancellationToken.None));
4307var frozenDocument = project.Documents.Single().WithFrozenPartialSemantics(CancellationToken.None);
4321var frozenDocument = project.Documents.First().WithFrozenPartialSemantics(CancellationToken.None);
4340var frozenDocument = forkedProject.Documents.Single().WithFrozenPartialSemantics(CancellationToken.None);
4364var frozenDocument = forkedProject.Documents.Single().WithFrozenPartialSemantics(CancellationToken.None);
4391var frozenDocument = document.WithFrozenPartialSemantics(CancellationToken.None);
4423var frozen = solution.GetRequiredDocument(documentIdToFreeze).WithFrozenPartialSemantics(CancellationToken.None);
4476var doc1Root = await document1.GetRequiredSyntaxRootAsync(CancellationToken.None);
4477var doc2Root = await document2.GetRequiredSyntaxRootAsync(CancellationToken.None);
4484var frozenDoc1 = document1.WithFrozenPartialSemantics(CancellationToken.None);
4487var frozenDoc1Root = await frozenDoc1.GetRequiredSyntaxRootAsync(CancellationToken.None);
4488var frozenDoc2Root = await frozenDoc2.GetRequiredSyntaxRootAsync(CancellationToken.None);
4499var frozenDoc2 = document2.WithFrozenPartialSemantics(CancellationToken.None);
4502var frozenDoc1Root = await frozenDoc1.GetRequiredSyntaxRootAsync(CancellationToken.None);
4503var frozenDoc2Root = await frozenDoc2.GetRequiredSyntaxRootAsync(CancellationToken.None);
4519Assert.False(await csBrokenProject.HasSuccessfullyLoadedAsync(CancellationToken.None));
4522Assert.True(await vbNormalProject.HasSuccessfullyLoadedAsync(CancellationToken.None));
4525Assert.True(await dependsOnBrokenProject.HasSuccessfullyLoadedAsync(CancellationToken.None));
4528Assert.True(await dependsOnVbNormalProject.HasSuccessfullyLoadedAsync(CancellationToken.None));
4532Assert.True(await transitivelyDependsOnBrokenProjects.HasSuccessfullyLoadedAsync(CancellationToken.None));
4536Assert.True(await transitivelyDependsOnNormalProjects.HasSuccessfullyLoadedAsync(CancellationToken.None));
4566var unused = await loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None);
4580var unused = loader.LoadTextAndVersionSynchronously(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None);
4603var strongTree = factory.ParseSyntaxTree("dummy", dummyProject.ParseOptions, text, CancellationToken.None);
4728Assert.True(provider.TryGetDiagnosticValue(newSyntaxTree, "CA1234", CancellationToken.None, out var severity));
4757Assert.True(provider.TryGetDiagnosticValue(syntaxTreeAfterAddingEditorConfig, "CA1234", CancellationToken.None, out var severity));
4766Assert.False(provider.TryGetDiagnosticValue(syntaxTreeAfterAddingEditorConfig, "CA1234", CancellationToken.None, out _));
4798Assert.True(provider.TryGetDiagnosticValue(syntaxTreeBeforeEditorConfigChange, "CA1234", CancellationToken.None, out var severity));
4811Assert.True(provider.TryGetDiagnosticValue(syntaxTreeBeforeEditorConfigChange, "CA6789", CancellationToken.None, out severity));
4916Assert.Null(document.GetSyntaxTreeSynchronously(CancellationToken.None));
5569var documentOptions = await document.GetOptionsAsync(CancellationToken.None);
5628var frozenSolution = project.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5647var frozenSolution = project.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5669var frozenSolution = project1.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5699var frozenSolution = project1.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5729var frozenSolution = project1.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5759var frozenSolution = project1.Solution.WithFrozenPartialCompilations(CancellationToken.None);
5794Assert.Equal("// source1", generatedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
5797? project1.Solution.WithFrozenPartialCompilations(CancellationToken.None)
5816Assert.Equal("// source1", forkedGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
5820Assert.Equal("// source2", forkedGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
5832var frozenSolution = project.Solution.WithFrozenPartialCompilations(CancellationToken.None);
SolutionTests\TextLoaderTests.cs (8)
110await Assert.ThrowsAsync<NotImplementedException>(() => loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None));
111await Assert.ThrowsAsync<NotImplementedException>(() => loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));
118Assert.Same(LoaderOverridesObsolete.Value, await loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None));
119Assert.Same(LoaderOverridesObsolete.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));
126Assert.Same(LoaderOverridesObsolete2.Value, await loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None));
127Assert.Same(LoaderOverridesObsolete2.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));
134Assert.Same(LoaderOverridesNew.Value, await loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None));
135Assert.Same(LoaderOverridesNew.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));
SyntaxPathTests.cs (23)
83Assert.True(path.TryResolve(tree, CancellationToken.None, out SyntaxNode node));
97Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
111Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
124Assert.True(path.TryResolve(tree, CancellationToken.None, out SyntaxNode node));
161Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
162Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
163Assert.True(path3.TryResolve(tree, CancellationToken.None, out SyntaxNode n3));
197Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
198Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
234Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
235Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
266Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
267Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _));
298Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
299Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _));
300Assert.False(path3.TryResolve(tree, CancellationToken.None, out SyntaxNode _));
329Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
330Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
360Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
361Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
399Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
400Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
418Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
Microsoft.CommonLanguageServerProtocol.Framework.Example (2)
Microsoft.CommonLanguageServerProtocol.Framework.Package (4)
Microsoft.CommonLanguageServerProtocol.Framework.UnitTests (10)
RequestExecutionQueueTests.cs (8)
56await Assert.ThrowsAsync<NotImplementedException>(() => requestExecutionQueue.ExecuteAsync(JToken.FromObject(new MockRequest(1)), ThrowingHandler.Name, lspServices, CancellationToken.None));
82await requestExecutionQueue.ExecuteAsync(JToken.FromObject(new MockRequest(1)), MutatingHandler.Name, lspServices, CancellationToken.None);
105var response = (MockResponse?)await requestExecutionQueue.ExecuteAsync(JToken.FromObject(new MockRequest(1)), TestMethodHandler.Name, lspServices, CancellationToken.None);
115var response = (MockResponse?)await requestExecutionQueue.ExecuteAsync(serializedRequest: null, TestParameterlessMethodHandler.Name, lspServices, CancellationToken.None);
125var response = await requestExecutionQueue.ExecuteAsync(JToken.FromObject(new MockRequest(1)), TestNotificationHandler.Name, lspServices, CancellationToken.None);
135var response = await requestExecutionQueue.ExecuteAsync(serializedRequest: null, TestParameterlessNotificationHandler.Name, lspServices, CancellationToken.None);
146var task1 = requestExecutionQueue.ExecuteAsync(request, TestMethodHandler.Name, lspServices, CancellationToken.None);
147var task2 = requestExecutionQueue.ExecuteAsync(request, TestMethodHandler.Name, lspServices, CancellationToken.None);
Microsoft.DotNet.Build.Tasks.Feed.Tests (1)
Microsoft.DotNet.Build.Tasks.Packaging (3)
Microsoft.DotNet.Helix.Sdk (2)
Microsoft.DotNet.SignCheckLibrary (1)
Microsoft.Extensions.AI (7)
Microsoft.Extensions.AI.Abstractions (19)
Microsoft.Extensions.AI.Abstractions.Tests (5)
Microsoft.Extensions.AI.Integration.Tests (1)
Microsoft.Extensions.AI.Tests (1)
Microsoft.Extensions.Caching.Hybrid (2)
Microsoft.Extensions.Caching.Hybrid.Tests (14)
Microsoft.Extensions.Caching.Memory (3)
Microsoft.Extensions.DependencyInjection (1)
Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (16)
ManualHealthCheckTests.cs (11)
20var healthCheckResult = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
38Assert.Equal(HealthStatus.Unhealthy, (await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None)).Status);
42var healthCheckResultUnhealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
47var healthCheckResultHealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
62Assert.Equal(HealthStatus.Unhealthy, (await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None)).Status);
67var healthCheckResultUnhealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
73var healthCheckResultHealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
89Assert.Equal(HealthStatus.Unhealthy, (await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None)).Status);
96var healthCheckResult2Unhealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
103var healthCheckResult1Unhealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
110var healthCheckResultHealthy = await manualHealthCheckService.CheckHealthAsync(context, CancellationToken.None);
Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (18)
Microsoft.Extensions.FileProviders.Physical (1)
Microsoft.Extensions.Hosting.Abstractions (1)
Microsoft.Extensions.Hosting.Testing.Tests (4)
Microsoft.Extensions.Http.Diagnostics.PerformanceTests (48)
Microsoft.Extensions.Http.Diagnostics.Tests (32)
Logging\HttpRequestReaderTest.cs (15)
102await reader.ReadRequestAsync(logRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
103await reader.ReadResponseAsync(logRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
159await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
160await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
230await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
231await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
305await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
306await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
365await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
435await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
436await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
502await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
503await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
570await reader.ReadRequestAsync(actualRecord, httpRequestMessage, requestHeadersBuffer, CancellationToken.None);
571await reader.ReadResponseAsync(actualRecord, httpResponseMessage, responseHeadersBuffer, CancellationToken.None);
Microsoft.Extensions.Http.Polly.Tests (11)
PolicyHttpMessageHandlerTest.cs (11)
49var response = await handler.SendAsync(new HttpRequestMessage(), CancellationToken.None);
94var response = await handler.SendAsync(expectedRequest, CancellationToken.None);
142var response = await invoke.SendAsync(new HttpRequestMessage(), CancellationToken.None);
194var response = await invoke.SendAsync(new HttpRequestMessage(), CancellationToken.None);
216await handler.SendAsync(new HttpRequestMessage(), CancellationToken.None);
264var response = await handler.SendAsync(new HttpRequestMessage(), CancellationToken.None);
291var response = await handler.SendAsync(request, CancellationToken.None);
322var response = await handler.SendAsync(request, CancellationToken.None);
344await handler.SendAsync(request, CancellationToken.None);
370await handler.SendAsync(request, CancellationToken.None);
403handler.SendAsync(request, CancellationToken.None).GetAwaiter().GetResult();
Microsoft.Extensions.Http.Resilience.PerformanceTests (6)
Microsoft.Extensions.Identity.Core (2)
Microsoft.Extensions.Options.Contextual.Tests (2)
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (3)
Microsoft.Extensions.ServiceDiscovery.Dns.Tests.Fuzzing (1)
Microsoft.Extensions.ServiceDiscovery.Tests (9)
Microsoft.Extensions.ServiceDiscovery.Yarp.Tests (7)
Microsoft.Extensions.TimeProvider.Testing.Tests (7)
FakeTimeProviderTests.cs (7)
292var t = timeProvider.Delay(TimeSpan.Zero, CancellationToken.None);
303var delay = timeProvider.Delay(TimeSpan.FromMilliseconds(1), CancellationToken.None);
362await Assert.ThrowsAsync<TimeoutException>(() => source.Task.WaitAsync(TimeSpan.FromTicks(-1), timeProvider, CancellationToken.None));
366await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => source.Task.WaitAsync(TimeSpan.FromMilliseconds(-2), timeProvider, CancellationToken.None));
375var t = source.Task.WaitAsync(TimeSpan.FromSeconds(100000), timeProvider, CancellationToken.None);
395var t = source.Task.WaitAsync(TimeSpan.FromMilliseconds(-1), timeProvider, CancellationToken.None);
414var t = source.Task.WaitAsync(TimeSpan.FromMilliseconds(1), timeProvider, CancellationToken.None);
Microsoft.Extensions.Validation.GeneratorTests (20)
ValidationsGenerator.ValidatableType.cs (20)
108await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
127await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
146await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
168await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
197await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
249await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
279await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
298await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
325await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
375await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
477await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
496await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
515await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
537await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
566await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
618await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
648await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
667await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
694await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
744await validatableInfo.ValidateAsync(instance, context, CancellationToken.None);
Microsoft.Gen.ComplianceReports.Unit.Tests (4)
Microsoft.Gen.ContextualOptions.Unit.Tests (9)
Microsoft.Gen.Logging.Unit.Tests (9)
Microsoft.Gen.MetadataExtractor.Unit.Tests (4)
Microsoft.Gen.Metrics.Unit.Tests (4)
Microsoft.Gen.MetricsReports.Unit.Tests (8)
Microsoft.JSInterop (11)
Microsoft.JSInterop.Tests (4)
Microsoft.Maui.Controls (1)
Microsoft.VisualStudio.LanguageServices (67)
Library\AbstractObjectList.cs (6)
150() => TryFillDescriptionAsync(index, (_VSOBJDESCOPTIONS)grfOptions, pobDesc, CancellationToken.None));
159GetBrowseObjectAsync(index, CancellationToken.None));
211() => GetExpandableAsync(index, listTypeExcluded, CancellationToken.None)) ? 1 : 0;
236() => GetListAsync(index, listType, flags, pobSrch, CancellationToken.None));
250var ppNavInfo = await GetNavInfoAsync(index, CancellationToken.None).ConfigureAwait(true);
271TryGetPropertyAsync(index, (_VSOBJLISTELEMPROPID)propid, CancellationToken.None));
Microsoft.VisualStudio.LanguageServices.CSharp (21)
CodeModel\CSharpCodeModelService.cs (13)
651var compilation = project.GetRequiredCompilationAsync(CancellationToken.None).Result;
1274var text = memberDeclaration.SyntaxTree.GetText(CancellationToken.None);
1354var text = memberDeclaration.SyntaxTree.GetText(CancellationToken.None);
1412var text = memberDeclaration.SyntaxTree.GetText(CancellationToken.None);
2764return document.ReplaceNodeSynchronously(fieldDeclaration, newFieldDeclaration, CancellationToken.None);
2785return document.ReplaceNodeSynchronously(enumDeclaration, newEnumDeclaration, CancellationToken.None);
2796var text = document.GetTextSynchronously(CancellationToken.None);
2811return document.ReplaceNodeSynchronously(attributeList, newAttributeList, CancellationToken.None);
2822return document.ReplaceNodeSynchronously(argumentList, newArgumentList, CancellationToken.None);
2832return document.ReplaceNodeSynchronously(parameterList, newParameterList, CancellationToken.None);
2837var text = document.GetTextSynchronously(CancellationToken.None);
3778var typeInfo = semanticModel.GetTypeInfo(type.Type, CancellationToken.None);
3866var typeInfo = semanticModel.GetTypeInfo(type.Type, CancellationToken.None);
Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (20)
DocumentOutline\DocumentOutlineTests.cs (6)
62mocks.TextBuffer, mocks.LanguageServiceBrokerCallback, mocks.FilePath, CancellationToken.None);
127var searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, string.Empty, CancellationToken.None);
131searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, "foo", CancellationToken.None);
136searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, "Method", CancellationToken.None);
142searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, "app", CancellationToken.None);
148searchedSymbols = DocumentOutlineViewModel.SearchDocumentSymbolData(model.DocumentSymbolData, "xyz", CancellationToken.None);
Microsoft.VisualStudio.LanguageServices.LiveShare (6)
Microsoft.VisualStudio.LanguageServices.Test.Utilities2 (2)
Microsoft.VisualStudio.LanguageServices.UnitTests (111)
ProjectSystemShim\VisualStudioProjectTests\AnalyzerReferenceTests.vb (8)
24"Project", LanguageNames.CSharp, CancellationToken.None)
46"Project", LanguageNames.CSharp, CancellationToken.None)
66"Project", LanguageNames.CSharp, CancellationToken.None)
85"Project", LanguageNames.CSharp, CancellationToken.None)
115"Project", LanguageNames.CSharp, CancellationToken.None)
131"Project", LanguageNames.CSharp, CancellationToken.None)
172"Project", LanguageNames.VisualBasic, CancellationToken.None)
212"Project", LanguageNames.CSharp, CancellationToken.None)
ProjectSystemShim\VisualStudioProjectTests\DynamicFileTests.vb (6)
19"project", LanguageNames.CSharp, CancellationToken.None)
33"project", LanguageNames.CSharp, CancellationToken.None)
43dynamicSourceFile.GetTextSynchronously(CancellationToken.None).ToString())
55"project", LanguageNames.CSharp, CancellationToken.None)
67"project", LanguageNames.CSharp, CancellationToken.None)
83"project", LanguageNames.CSharp, CancellationToken.None)
ProjectSystemShim\VisualStudioProjectTests\MetadataToProjectReferenceConversionTests.vb (25)
21"project1", LanguageNames.CSharp, CancellationToken.None)
24"project2", LanguageNames.CSharp, CancellationToken.None)
56"project1", LanguageNames.CSharp, CancellationToken.None)
59"project2", LanguageNames.CSharp, CancellationToken.None)
92"referencingProject", LanguageNames.CSharp, CancellationToken.None)
95"project1", LanguageNames.CSharp, CancellationToken.None)
110"project2", LanguageNames.CSharp, CancellationToken.None)
128"referencingProject", LanguageNames.CSharp, CancellationToken.None)
131"project1", LanguageNames.CSharp, CancellationToken.None)
146"project2", LanguageNames.CSharp, CancellationToken.None)
169Dim referencingProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencingProject", LanguageNames.CSharp, CancellationToken.None)
170Dim referencedProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencedProject", LanguageNames.CSharp, CancellationToken.None)
196Dim referencingProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencingProject", LanguageNames.CSharp, CancellationToken.None)
197Dim referencedProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencedProject", LanguageNames.CSharp, CancellationToken.None)
227Dim referencingProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencingProject", LanguageNames.CSharp, CancellationToken.None)
228Dim referencedProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencedProject", LanguageNames.CSharp, CancellationToken.None)
259Dim referencingProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencingProject", LanguageNames.CSharp, CancellationToken.None)
260Dim referencedProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencedProject", LanguageNames.CSharp, CancellationToken.None)
293Dim referencingProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencingProject", LanguageNames.CSharp, CancellationToken.None)
294Dim referencedProject = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("referencedProject", LanguageNames.CSharp, CancellationToken.None)
319Dim project1 = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("project1", LanguageNames.CSharp, CancellationToken.None)
320Dim project2 = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("project2", LanguageNames.CSharp, CancellationToken.None)
340Dim project1 = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("project1", LanguageNames.CSharp, CancellationToken.None)
341Dim project2 = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("project2", LanguageNames.CSharp, CancellationToken.None)
361Dim project = Await environment.ProjectFactory.CreateAndAddToWorkspaceAsync("project", LanguageNames.CSharp, CancellationToken.None)
ProjectSystemShim\VisualStudioProjectTests\WorkspaceChangedEventTests.vb (7)
20"Project", LanguageNames.CSharp, CancellationToken.None)
39"Project", LanguageNames.CSharp, CancellationToken.None)
60"Project", LanguageNames.CSharp, CancellationToken.None)
80"Project", LanguageNames.CSharp, CancellationToken.None)
99"Project", LanguageNames.CSharp, CancellationToken.None)
115"Project", LanguageNames.CSharp, CancellationToken.None)
129"Project", LanguageNames.CSharp, CancellationToken.None)
Venus\DocumentServiceTests.vb (6)
40Dim spans = Await spanMapper.MapSpansAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), {New TextSpan(position, length:=0)}, CancellationToken.None)
64Dim spans = Await spanMapper.MapSpansAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), {New TextSpan(position, length:=0), New TextSpan(start:=1, length:=0), New TextSpan(position + 1, length:=0)}, CancellationToken.None)
139Dim result = Await excerptService.TryExcerptAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), GetNamedSpan(subjectDocument), ExcerptMode.SingleLine, ClassificationOptions.Default, CancellationToken.None)
178Dim result = Await excerptService.TryExcerptAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), GetNamedSpan(subjectDocument), ExcerptMode.Tooltip, ClassificationOptions.Default, CancellationToken.None)
225Dim result = Await excerptService.TryExcerptAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), GetNamedSpan(subjectDocument), ExcerptMode.Tooltip, ClassificationOptions.Default, CancellationToken.None)
278Dim result = Await excerptService.TryExcerptAsync(workspace.CurrentSolution.GetDocument(subjectDocument.Id), GetNamedSpan(subjectDocument), ExcerptMode.SingleLine, ClassificationOptions.Default, CancellationToken.None)
Microsoft.VisualStudio.LanguageServices.VisualBasic (20)
CodeModel\VisualBasicCodeModelService.vb (12)
1277Dim text = document.GetTextSynchronously(CancellationToken.None)
1332Return document.ReplaceNodeSynchronously(declarator, newDeclarator, CancellationToken.None)
1345Return document.ReplaceNodeSynchronously(declaration, newDeclaration, CancellationToken.None)
1358Dim text = document.GetTextSynchronously(CancellationToken.None)
1366Return document.ReplaceNodeSynchronously(attributeList, newAttributeList, CancellationToken.None)
1374Return document.ReplaceNodeSynchronously(argumentList, newArgumentList, CancellationToken.None)
1381Return document.ReplaceNodeSynchronously(parameterList, newParameterList, CancellationToken.None)
2251Dim text = member.SyntaxTree.GetText(CancellationToken.None)
2480Dim text = member.SyntaxTree.GetText(CancellationToken.None)
2506Dim text = member.SyntaxTree.GetText(CancellationToken.None)
4295Dim typeInfo = semanticModel.GetTypeInfo(inheritsType, CancellationToken.None)
4367Dim typeInfo = semanticModel.GetTypeInfo(inheritsType, CancellationToken.None)
Microsoft.VisualStudio.LanguageServices.Xaml (1)
Replay (4)
Roslyn.Diagnostics.Analyzers (23)
Roslyn.Diagnostics.CSharp.Analyzers (1)
Roslyn.VisualStudio.DiagnosticsWindow (4)
Roslyn.VisualStudio.Next.UnitTests (303)
Remote\SerializationValidator.cs (9)
85var data = await AssetStorage.GetTestAccessor().GetRequiredAssetAsync(checksum, CancellationToken.None).ConfigureAwait(false);
98Serializer.Serialize(data.Value, writer, CancellationToken.None);
106var result = Serializer.Deserialize(data.Kind, reader, CancellationToken.None);
114scope.SolutionChecksum, this.Services.SolutionServices, CancellationToken.None).ConfigureAwait(false);
145(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v));
149(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v));
155(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v));
162(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v));
169(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v));
Remote\SnapshotSerializationTests.cs (49)
75var data = await scope.GetTestAccessor().GetAssetAsync(checksum, CancellationToken.None);
88using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
108using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
121using var scope = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None);
143using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None);
157using var scope = await validator.AssetStorage.StoreAssetsAsync(document.Project.Solution, CancellationToken.None);
177using var scope = await validator.AssetStorage.StoreAssetsAsync(document.Project.Solution, CancellationToken.None);
187var firstProjectChecksum = await solution.GetProject(solution.ProjectIds[0]).State.GetChecksumAsync(CancellationToken.None);
188var secondProjectChecksum = await solution.GetProject(solution.ProjectIds[1]).State.GetChecksumAsync(CancellationToken.None);
192using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
211using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
223using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
237using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
258using (var scope1 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false))
264using (var scope2 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None).ConfigureAwait(false))
285var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
299var scope1 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
307using var scope2 = await validator.AssetStorage.StoreAssetsAsync(recovered, CancellationToken.None);
321using var scope3 = await validator.AssetStorage.StoreAssetsAsync(roundtrip, CancellationToken.None);
339var scope1 = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
347using var scope2 = await validator.AssetStorage.StoreAssetsAsync(recovered, CancellationToken.None);
362using var scope3 = await validator.AssetStorage.StoreAssetsAsync(roundtrip, CancellationToken.None);
381var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
395var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
409var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
430var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
451var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
466var assetFromFile = new SolutionAsset(serializer.CreateChecksum(reference, CancellationToken.None), reference);
491using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None);
511using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None);
524using var snapshot = await validator.AssetStorage.StoreAssetsAsync(project.Solution, CancellationToken.None);
537var metadata = serializer.CreateChecksum(new MissingMetadataReference(), CancellationToken.None);
538var analyzer = serializer.CreateChecksum(new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing"), new MissingAnalyzerLoader()), CancellationToken.None);
552var checksum = await project.State.GetChecksumAsync(CancellationToken.None);
590using var scope = await validator.AssetStorage.StoreAssetsAsync(solution, CancellationToken.None);
594var compilation = await recovered.Projects.First().GetCompilationAsync(CancellationToken.None);
615serializer.Serialize(serializableSourceText, objectWriter, CancellationToken.None);
622var newText = (SerializableSourceText)serializer.Deserialize(serializableSourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
623Assert.Equal(sourceText.ToString(), newText.GetText(CancellationToken.None).ToString());
633serializer.Serialize(serializableSourceText, objectWriter, CancellationToken.None);
640var newText = (SerializableSourceText)serializer.Deserialize(serializableSourceText.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
641Assert.Equal(sourceText.ToString(), newText.GetText(CancellationToken.None).ToString());
662serializer.Serialize(originalOptions, objectWriter, CancellationToken.None);
667var recoveredOptions = (CompilationOptions)serializer.Deserialize(originalOptions.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
669var original = serializer.CreateChecksum(originalOptions, CancellationToken.None);
670var recovered = serializer.CreateChecksum(recoveredOptions, CancellationToken.None);
681serializer.Serialize(asset.Value, writer, CancellationToken.None);
686var recovered = serializer.Deserialize(asset.Kind, reader, CancellationToken.None);
687var checksum = recovered is SerializableSourceText text ? text.ContentChecksum : serializer.CreateChecksum(recovered, CancellationToken.None);
Services\AssetProviderTests.cs (18)
54var stored = await provider.GetAssetAsync<object>(AssetPath.FullLookupForTesting, checksum, CancellationToken.None);
58await provider.GetAssetsAsync<object, VoidResult>(AssetPath.FullLookupForTesting, [checksum], (checksum, asset, _) => stored2.Add((checksum, asset)), default, CancellationToken.None);
74await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
76var map = await solution.GetAssetMapAsync(projectConeId: null, CancellationToken.None);
85await service.GetAssetsAsync<object>(AssetPath.FullLookupForTesting, [.. map.Keys], CancellationToken.None);
102await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
104var map = await solution.GetAssetMapAsync(projectConeId: null, CancellationToken.None);
113await service.SynchronizeSolutionAssetsAsync(await solution.CompilationState.GetChecksumAsync(CancellationToken.None), CancellationToken.None);
127await project.State.GetChecksumAsync(CancellationToken.None);
129var map = await project.GetAssetMapAsync(CancellationToken.None);
140allProjectChecksums.Add(await project.State.GetStateChecksumsAsync(CancellationToken.None));
142await service.SynchronizeProjectAssetsAsync(allProjectChecksums, CancellationToken.None);
156await project.State.GetChecksumAsync(CancellationToken.None);
158var map = await project.GetAssetMapAsync(CancellationToken.None);
169var stateChecksums = await project.State.GetStateChecksumsAsync(CancellationToken.None);
175AssetPath.FullLookupForTesting, textChecksums, CancellationToken.None);
180AssetPath.FullLookupForTesting, textChecksumsReversed, CancellationToken.None);
Services\ServiceHubServicesTests.cs (44)
79await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
80await remoteWorkpace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
101var oldState = await oldDocument.State.GetStateChecksumsAsync(CancellationToken.None);
109var newState = await newDocument.State.GetStateChecksumsAsync(CancellationToken.None);
114CancellationToken.None);
118Assert.Equal(newText.ToString(), (await serializableRemoteText.GetTextAsync(CancellationToken.None)).ToString());
124await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
127await solution.AppendAssetMapAsync(map, CancellationToken.None);
152var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
153await remoteWorkspace.UpdatePrimaryBranchSolutionAsync(assetProvider, solutionChecksum, CancellationToken.None);
203var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
204await remoteWorkspace.UpdatePrimaryBranchSolutionAsync(assetProvider, solutionChecksum, CancellationToken.None);
215CancellationToken.None);
249await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
250await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
255await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
256await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
275await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
276await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
283await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
284await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
291await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
292await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
325await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
326await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
339await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
340await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
353await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
354await remoteWorkspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
730CancellationToken.None).ConfigureAwait(false);
754Assert.Equal("// generated document 2", sourceGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
759Assert.Equal("// generated document 1", sourceGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
814CancellationToken.None).ConfigureAwait(false);
839Assert.Equal("// generated document 1", sourceGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
869CancellationToken.None).ConfigureAwait(false);
893Assert.Equal("// generated document 2", sourceGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());
1521await solution.CompilationState.GetChecksumAsync(CancellationToken.None),
1522await remoteSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
1603""")], CancellationToken.None);
1616using (CopilotChangeAnalysisUtilities.LogCopilotChangeAnalysis("TestCode", accepted: true, "TestProposalId", result, CancellationToken.None))
1701var map = await solution.GetAssetMapAsync(projectConeId: null, CancellationToken.None);
1719return SourceText.From(document.State.GetTextSynchronously(CancellationToken.None).ToString() + csAddition);
1722return SourceText.From(document.State.GetTextSynchronously(CancellationToken.None).ToString() + vbAddition);
1746CancellationToken.None);
Services\ServiceHubServicesTests_ExtensionMessageHandler.cs (40)
41await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
44await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
61await extensionMessageHandlerService.UnregisterExtensionAsync("TempPath", CancellationToken.None);
79workspace.CurrentSolution, "MessageName", "JsonMessage", CancellationToken.None);
102workspace.CurrentSolution.Projects.Single().Documents.Single(), "MessageName", "JsonMessage", CancellationToken.None);
119await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None);
136await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
138await extensionMessageHandlerService.UnregisterExtensionAsync("TempPath", CancellationToken.None);
141await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None);
178await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
181var result = await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None);
207await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
210var result = await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None);
235await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
239async () => await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None));
272await extensionMessageHandlerService.RegisterExtensionAsync("TempPath", CancellationToken.None);
275var result = await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath", CancellationToken.None);
351"NonRegisteredHandlerName", jsonMessage: "0", CancellationToken.None);
377"HandlerName", jsonMessage: "[]", CancellationToken.None);
412"HandlerName", jsonMessage: "0", CancellationToken.None);
450"HandlerName", jsonMessage: "0", CancellationToken.None);
497"HandlerName", jsonMessage: "0", CancellationToken.None);
508"HandlerName", jsonMessage: "0", CancellationToken.None);
542"HandlerName", jsonMessage: "0", CancellationToken.None));
573"HandlerName", jsonMessage: "0", CancellationToken.None);
603await extensionMessageHandlerService.UnregisterExtensionAsync("TempPath", CancellationToken.None);
609"HandlerName", jsonMessage: "0", CancellationToken.None);
644await extensionMessageHandlerService.RegisterExtensionAsync("TempPath1", CancellationToken.None);
647await extensionMessageHandlerService.RegisterExtensionAsync("TempPath2", CancellationToken.None);
650var messageNames1 = await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath1", CancellationToken.None);
653var messageNames2 = await extensionMessageHandlerService.GetExtensionMessageNamesAsync("TempPath2", CancellationToken.None);
662"HandlerName", jsonMessage: "0", CancellationToken.None);
686"HandlerName", jsonMessage: "0", CancellationToken.None);
692"HandlerName", jsonMessage: "0", CancellationToken.None);
729await extensionMessageHandlerService.RegisterExtensionAsync(@"TempPath\a.dll", CancellationToken.None);
730await extensionMessageHandlerService.GetExtensionMessageNamesAsync(@"TempPath\a.dll", CancellationToken.None);
734await extensionMessageHandlerService.RegisterExtensionAsync(@"TempPath\b.dll", CancellationToken.None);
735await extensionMessageHandlerService.GetExtensionMessageNamesAsync(@"TempPath\b.dll", CancellationToken.None);
739await extensionMessageHandlerService.UnregisterExtensionAsync(@"TempPath\a.dll", CancellationToken.None);
744await extensionMessageHandlerService.UnregisterExtensionAsync(@"TempPath\b.dll", CancellationToken.None);
Services\SolutionServiceTests.cs (135)
53var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
54var synched = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
56Assert.Equal(solutionChecksum, await synched.CompilationState.GetChecksumAsync(CancellationToken.None));
68var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
71var synched = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch, cancellationToken: CancellationToken.None);
72Assert.Equal(solutionChecksum, await synched.CompilationState.GetChecksumAsync(CancellationToken.None));
92var solutionChecksum = await workspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None);
93var solution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
121var solutionChecksum = await workspace.CurrentSolution.CompilationState.GetChecksumAsync(CancellationToken.None);
122var solution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
144var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
146var first = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
147var second = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
444await solution1.CompilationState.GetChecksumAsync(CancellationToken.None),
446CancellationToken.None);
457var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
458await remoteWorkspace.UpdatePrimaryBranchSolutionAsync(assetProvider, solutionChecksum, CancellationToken.None);
461return await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
467Assert.Equal(await givenSolution.CompilationState.GetChecksumAsync(CancellationToken.None), await remoteSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
481var solutionChecksum1 = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
491var solutionChecksum2 = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
507var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
508var synched = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
509Assert.Equal(solutionChecksum, await synched.CompilationState.GetChecksumAsync(CancellationToken.None));
517solutionChecksum = await frozenSolution1.CompilationState.GetChecksumAsync(CancellationToken.None);
518synched = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
519Assert.Equal(solutionChecksum, await synched.CompilationState.GetChecksumAsync(CancellationToken.None));
526solutionChecksum = await frozenSolution2.CompilationState.GetChecksumAsync(CancellationToken.None);
527synched = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
528Assert.Equal(solutionChecksum, await synched.CompilationState.GetChecksumAsync(CancellationToken.None));
551await solution.AppendAssetMapAsync(map, CancellationToken.None);
553var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
554var syncedFullSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
556Assert.Equal(solutionChecksum, await syncedFullSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
560var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
561await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
562var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
566var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
567await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
568var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
592await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
593var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
594var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
599await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
600var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
601var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
605await solution.AppendAssetMapAsync(map, CancellationToken.None);
606var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
607var syncedFullSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
609Assert.Equal(solutionChecksum, await syncedFullSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
633await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
634var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
635var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
640await solution.AppendAssetMapAsync(map, project3.Id, CancellationToken.None);
641var project3Checksum = await solution.CompilationState.GetChecksumAsync(project3.Id, CancellationToken.None);
642var project3SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project3Checksum, updatePrimaryBranch: false, CancellationToken.None);
667await solution.AppendAssetMapAsync(map, project3.Id, CancellationToken.None);
668var project3Checksum = await solution.CompilationState.GetChecksumAsync(project3.Id, CancellationToken.None);
669var project3SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project3Checksum, updatePrimaryBranch: false, CancellationToken.None);
673await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
674var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
675var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
680await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
681var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
682var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
709await solution.AppendAssetMapAsync(map, project3.Id, CancellationToken.None);
710var project3Checksum = await solution.CompilationState.GetChecksumAsync(project3.Id, CancellationToken.None);
711var project3SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project3Checksum, updatePrimaryBranch: false, CancellationToken.None);
715await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
716var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
717var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
721await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
722var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
723var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
749await solution.AppendAssetMapAsync(map, project3.Id, CancellationToken.None);
750var project3Checksum = await solution.CompilationState.GetChecksumAsync(project3.Id, CancellationToken.None);
751var project3SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project3Checksum, updatePrimaryBranch: false, CancellationToken.None);
755await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
756var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
757var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
761await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
762var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
763var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
787await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
788var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
789var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
794await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
795var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
796var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
820await solution.AppendAssetMapAsync(map, CancellationToken.None);
821var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
822var fullSyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
832await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
833var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
834var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
844await solution.AppendAssetMapAsync(map, project2.Id, CancellationToken.None);
845var project2Checksum = await solution.CompilationState.GetChecksumAsync(project2.Id, CancellationToken.None);
846var project2SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project2Checksum, updatePrimaryBranch: false, CancellationToken.None);
875await solution.AppendAssetMapAsync(map, CancellationToken.None);
876var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
877var fullSyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
888await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
889var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
890var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
921var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
944await solution.AppendAssetMapAsync(map, CancellationToken.None);
945var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
946var fullSyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: true, CancellationToken.None);
957await solution.AppendAssetMapAsync(map, project1.Id, CancellationToken.None);
958var project1Checksum = await solution.CompilationState.GetChecksumAsync(project1.Id, CancellationToken.None);
959var project1SyncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, project1Checksum, updatePrimaryBranch: false, CancellationToken.None);
1103var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1104var syncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
1132var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1133var syncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch, CancellationToken.None);
1159var checksumUpdater = new SolutionChecksumUpdater(workspace, listenerProvider, CancellationToken.None);
1163var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1164var syncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch, CancellationToken.None);
1213var checksumUpdater = new SolutionChecksumUpdater(workspace, listenerProvider, CancellationToken.None);
1217var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1218var syncedSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch, CancellationToken.None);
1278var solutionChecksum = await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1281await remoteWorkspace.UpdatePrimaryBranchSolutionAsync(assetProvider, solutionChecksum, CancellationToken.None);
1282var recoveredSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, solutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
1286Assert.Equal(solutionChecksum, await recoveredSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
1290var newSolutionChecksum = await newSolution.CompilationState.GetChecksumAsync(CancellationToken.None);
1291await newSolution.AppendAssetMapAsync(map, CancellationToken.None);
1294var recoveredNewSolution = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, newSolutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
1296Assert.Equal(newSolutionChecksum, await recoveredNewSolution.CompilationState.GetChecksumAsync(CancellationToken.None));
1299await remoteWorkspace.UpdatePrimaryBranchSolutionAsync(assetProvider, newSolutionChecksum, CancellationToken.None);
1300var third = await remoteWorkspace.GetTestAccessor().GetSolutionAsync(assetProvider, newSolutionChecksum, updatePrimaryBranch: false, CancellationToken.None);
1302Assert.Equal(newSolutionChecksum, await third.CompilationState.GetChecksumAsync(CancellationToken.None));
1310await solution.CompilationState.GetChecksumAsync(CancellationToken.None);
1313await solution.AppendAssetMapAsync(map, CancellationToken.None);
Security.TransportSecurity.IntegrationTests (2)
SemanticSearch.BuildTask (2)
System.Collections.Concurrent (16)
System\Collections\Concurrent\BlockingCollection.cs (16)
255TryAddWithNoTimeValidation(item, Timeout.Infinite, CancellationToken.None);
304return TryAddWithNoTimeValidation(item, 0, CancellationToken.None);
328return TryAddWithNoTimeValidation(item, (int)timeout.TotalMilliseconds, CancellationToken.None);
350return TryAddWithNoTimeValidation(item, millisecondsTimeout, CancellationToken.None);
513if (!TryTake(out item, Timeout.Infinite, CancellationToken.None))
557return TryTake(out item, 0, CancellationToken.None);
580return TryTakeWithNoTimeValidation(out item, (int)timeout.TotalMilliseconds, CancellationToken.None, null);
601return TryTakeWithNoTimeValidation(out item, millisecondsTimeout, CancellationToken.None, null);
765TryAddToAny(collections, item, Timeout.Infinite, CancellationToken.None);
835return TryAddToAny(collections, item, 0, CancellationToken.None);
865return TryAddToAnyCore(collections, item, (int)timeout.TotalMilliseconds, CancellationToken.None);
892return TryAddToAnyCore(collections, item, millisecondsTimeout, CancellationToken.None);
1138return TakeFromAny(collections, out item, CancellationToken.None);
1227return TryTakeFromAnyCore(collections, out item, (int)timeout.TotalMilliseconds, false, CancellationToken.None);
1257return TryTakeFromAnyCore(collections, out item, millisecondsTimeout, false, CancellationToken.None);
1600return GetConsumingEnumerable(CancellationToken.None);
System.ComponentModel.EventBasedAsync (1)
System.Data.Common (12)
System.Formats.Tar (8)
System.IO.Hashing (1)
System.IO.Pipelines (6)
System.IO.Ports (3)
System.Linq.AsyncEnumerable (97)
System.Linq.Expressions (1)
System.Linq.Parallel (2)
System.Net.Http.Json (1)
System.Net.HttpListener (1)
System.Net.Mail (2)
System\Net\DelegatedStream.cs (2)
61return TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
70return TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
System.Net.Ping (5)
System\Net\NetworkInformation\Ping.cs (5)
530}, AsyncOperationManager.CreateOperation(userToken), CancellationToken.None, TaskContinuationOptions.DenyChildAttach, TaskScheduler.Default);
565return SendPingAsync(address, timeout, buffer, options, CancellationToken.None);
581/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
605return SendPingAsync(hostNameOrAddress, timeout, buffer, options, CancellationToken.None);
624/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
System.Private.CoreLib (40)
src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (2)
728TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
1141TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (2)
459=> TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
742=> TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (5)
81public Task CopyToAsync(Stream destination, int bufferSize) => CopyToAsync(destination, bufferSize, CancellationToken.None);
189public Task FlushAsync() => FlushAsync(CancellationToken.None);
301public Task<int> ReadAsync(byte[] buffer, int offset, int count) => ReadAsync(buffer, offset, count, CancellationToken.None);
657base(function, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach)
721public Task WriteAsync(byte[] buffer, int offset, int count) => WriteAsync(buffer, offset, count, CancellationToken.None);
src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (7)
543}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
550}, new TupleSlim<TextWriter, string?>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
589}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
606}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
613}, new TupleSlim<TextWriter, string?>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
653}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
673CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (2)
86=> TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
89=> TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
System.Security.Cryptography.Cose (7)
System.ServiceModel.Federation (5)
System\Runtime\TaskHelpers.cs (4)
33}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
63}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
87}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
119}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
System.ServiceModel.Primitives (12)
Internals\System\Runtime\TaskHelpers.cs (4)
48}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
78}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
102}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
134}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);
System.ServiceModel.Primitives.Tests (1)
System.Text.RegularExpressions (11)
System\Threading\StackHelper.cs (11)
40.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
51.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
64.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
79.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
96.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
115.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
123.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
133.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
145.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
159.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
175.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
System.Text.RegularExpressions.Generator (11)
src\libraries\System.Text.RegularExpressions\src\System\Threading\StackHelper.cs (11)
40.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
51.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
64.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
79.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
96.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
115.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
123.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
133.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
145.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
159.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
175.ContinueWith(t => t.GetAwaiter().GetResult(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default)
System.Threading (6)
System.Threading.Channels (2)
System.Threading.Tasks.Dataflow (57)
Base\DataflowBlock.cs (17)
261return SendAsync<TInput>(target, item, CancellationToken.None);
513CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
527CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
788return ReceiveAsync(source, Common.InfiniteTimeSpan, CancellationToken.None);
825return ReceiveAsync(source, timeout, CancellationToken.None);
866return Receive(source, Common.InfiniteTimeSpan, CancellationToken.None);
905return Receive(source, timeout, CancellationToken.None);
1296}, this, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
1307}, this, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
1328}, this, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
1384return OutputAvailableAsync<TOutput>(source, CancellationToken.None);
1889CancellationToken.None, Common.GetCreationOptionsForTask(), scheduler);
1923CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(dataflowBlockOptions.CancellationToken, CancellationToken.None);
1988}, CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);
2057}, CancellationToken.None, Common.GetContinuationOptions(), scheduler);
2386CancellationToken.None,
2399CancellationToken.None,
Blocks\BatchBlock.cs (4)
75CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);
86}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
547}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
655exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
Blocks\BroadcastBlock.cs (6)
93}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
271exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
404}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
650}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
864}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
947this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
Blocks\BufferBlock.cs (3)
75}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
272exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
407}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
Blocks\JoinBlock.cs (5)
86CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);
97}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
305CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);
316}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
1335}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
Blocks\TransformBlock.cs (3)
145}, _source, CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);
156}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
261}, Tuple.Create(this, messageWithId), CancellationToken.None,
Internal\SourceCore.cs (3)
523}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
786}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
920this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);
System.Threading.Tasks.Parallel (3)
Test.Utilities (24)
TestDiscoveryWorker (1)
Text.Analyzers (23)
VBCSCompiler (2)
VBCSCompiler.UnitTests (4)
Wasm.Performance.Driver (1)
WebSocketSample (5)
WebTransportInteractiveSampleApp (2)
WebTransportSampleApp (3)