public void Send_ExecutesDelegate_NoThrow() { var syncContext = new SingleThreadedSynchronizationContext(); int?executingThread = null; syncContext.Send(s => executingThread = Environment.CurrentManagedThreadId, null); Assert.Equal(Environment.CurrentManagedThreadId, executingThread); }
public void Send_ExecutesDelegate_Throws() { var syncContext = new SingleThreadedSynchronizationContext(); Exception expected = new InvalidOperationException(); TargetInvocationException?actual = Assert.Throws <TargetInvocationException>(() => syncContext.Send(s => throw expected, null)); Assert.Same(expected, actual.InnerException); }
public override ScenarioInstance <SyncContextConfiguration> CreateInstance() { var syncContext = new SingleThreadedSynchronizationContext(); var instance = new ScenarioInstance <SyncContextConfiguration>(new SyncContextConfiguration()); instance.Disposing += (s, e) => syncContext.Dispose(); return(instance); }
public void TesSend() { var sendComplete = false; var sync = new SingleThreadedSynchronizationContext(); sync.Send(state => { sendComplete = true; }, null); Assert.IsTrue(sendComplete); }
public void TestPost() { var postComplete = false; var sync = new SingleThreadedSynchronizationContext(); var latch = new ManualResetEvent(false); sync.Post(state => { postComplete = true; latch.Set(); }, null); Assert.IsFalse(postComplete); latch.WaitOne(); Assert.IsTrue(postComplete); }
public void Send_OnDifferentThread_ExecutesDelegateAndWaits_Throws() { int originalThreadId = Environment.CurrentManagedThreadId; var syncContext = new SingleThreadedSynchronizationContext(); var frame = new SingleThreadedSynchronizationContext.Frame(); var task = Task.Run(delegate { try { var expectedException = new InvalidOperationException(); var actualException = Assert.Throws <TargetInvocationException>(() => syncContext.Send(s => throw expectedException, null)); Assert.Same(expectedException, actualException.InnerException); } finally { frame.Continue = false; } });
public void AddHttpClient_GetAwaiterAndResult_InSingleThreadedSynchronizationContext_ShouldNotHangs() { // Arrange using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10))) { var token = cts.Token; token.Register(() => throw new OperationCanceledException(token)); var serviceCollection = new ServiceCollection(); serviceCollection.AddHttpClient("example.com") .ConfigurePrimaryHttpMessageHandler(() => { var mockHandler = new Mock <HttpMessageHandler>(); mockHandler .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .Returns(async() => { await Task.Delay(1).ConfigureAwait(false); return(new HttpResponseMessage(HttpStatusCode.OK)); }); return(mockHandler.Object); }); var services = serviceCollection.BuildServiceProvider(); var factory = services.GetRequiredService <IHttpClientFactory>(); var client = factory.CreateClient("example.com"); var hangs = true; SingleThreadedSynchronizationContext.Run(() => { // Act client.GetAsync("http://example.com", token).GetAwaiter().GetResult(); hangs = false; }); // Assert Assert.False(hangs); } }
public static void Run(Action action) { var previous = Current; var context = new SingleThreadedSynchronizationContext(); SetSynchronizationContext(context); try { action(); while (context._queue.Count > 0) { var item = context._queue.Dequeue(); item.Callback(item.State); } } finally { SetSynchronizationContext(previous); } }
public void Send_OnDifferentThread_ExecutesDelegateAndWaits() { int originalThreadId = Environment.CurrentManagedThreadId; var syncContext = new SingleThreadedSynchronizationContext(); var frame = new SingleThreadedSynchronizationContext.Frame(); var task = Task.Run(delegate { try { int?observedThreadId = null; syncContext.Send(s => observedThreadId = Environment.CurrentManagedThreadId, null); Assert.Equal(originalThreadId, observedThreadId); } finally { frame.Continue = false; } }); syncContext.PushFrame(frame); task.GetAwaiter().GetResult(); }
public ReentrantSemaphoreTestBase(ITestOutputHelper logger) : base(logger) { this.Dispatcher = SingleThreadedSynchronizationContext.New(); }
internal async Task GeneratedMethods_WithOutParams_DoNotCauseDeadlocks(string fixture) { var traceWriter = new TestTraceWriter(TraceLevel.Verbose); ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = @"TestScripts\FunctionGeneration", TraceWriter = traceWriter }; string secretsPath = Path.Combine(Path.GetTempPath(), @"FunctionTests\Secrets"); ISecretsRepository repository = new FileSystemSecretsRepository(secretsPath); WebHostSettings webHostSettings = new WebHostSettings(); webHostSettings.SecretsPath = secretsPath; var secretManager = new SecretManager(SettingsManager, repository, NullTraceWriter.Instance); using (var manager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), SettingsManager, webHostSettings)) { Thread runLoopThread = new Thread(_ => { manager.RunAndBlock(CancellationToken.None); }); runLoopThread.IsBackground = true; runLoopThread.Start(); await TestHelpers.Await(() => { return(manager.State == ScriptHostState.Running); }); var request = new HttpRequestMessage(HttpMethod.Get, string.Format("http://localhost/api/httptrigger-{0}", fixture)); FunctionDescriptor function = manager.GetHttpFunctionOrNull(request); SynchronizationContext currentContext = SynchronizationContext.Current; var resetEvent = new ManualResetEventSlim(); try { var requestThread = new Thread(() => { var context = new SingleThreadedSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(context); manager.HandleRequestAsync(function, request, CancellationToken.None) .ContinueWith(task => resetEvent.Set()); Thread.Sleep(500); context.Run(); }); requestThread.IsBackground = true; requestThread.Start(); bool threadSignaled = resetEvent.Wait(TimeSpan.FromSeconds(10)); requestThread.Abort(); Assert.True(threadSignaled, "Thread execution did not complete"); } finally { SynchronizationContext.SetSynchronizationContext(currentContext); manager.Stop(); } } }
public void CreateCopy_ReturnsInstanceOfCorrectType() { var syncContext = new SingleThreadedSynchronizationContext(); Assert.IsType <SingleThreadedSynchronizationContext>(syncContext.CreateCopy()); }
public static void SendAsyncHttpClientRequests(HttpClient client, bool tracingDisabled, string url, string requestContent) { void Invoke() { // Insert a call to the Tracer.Instance to include an AssemblyRef to Datadog.Trace assembly in the final executable Console.WriteLine($"[HttpClient] sending requests to {url}"); if (tracingDisabled) { client.DefaultRequestHeaders.Add(HttpHeaderNames.TracingEnabled, "false"); } using (Tracer.Instance.StartActive("HttpClientRequestAsync")) { using (Tracer.Instance.StartActive("DeleteAsync")) { client.DeleteAsync(url).Wait(); Console.WriteLine("Received response for client.DeleteAsync(String)"); client.DeleteAsync(new Uri(url)).Wait(); Console.WriteLine("Received response for client.DeleteAsync(Uri)"); client.DeleteAsync(url, CancellationToken.None).Wait(); Console.WriteLine("Received response for client.DeleteAsync(String, CancellationToken)"); client.DeleteAsync(new Uri(url), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.DeleteAsync(Uri, CancellationToken)"); } using (Tracer.Instance.StartActive("GetAsync")) { client.GetAsync(url).Wait(); Console.WriteLine("Received response for client.GetAsync(String)"); client.GetAsync(new Uri(url)).Wait(); Console.WriteLine("Received response for client.GetAsync(Uri)"); client.GetAsync(url, CancellationToken.None).Wait(); Console.WriteLine("Received response for client.GetAsync(String, CancellationToken)"); client.GetAsync(new Uri(url), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.GetAsync(Uri, CancellationToken)"); client.GetAsync(url, HttpCompletionOption.ResponseContentRead).Wait(); Console.WriteLine("Received response for client.GetAsync(String, HttpCompletionOption)"); client.GetAsync(new Uri(url), HttpCompletionOption.ResponseContentRead).Wait(); Console.WriteLine("Received response for client.GetAsync(Uri, HttpCompletionOption)"); client.GetAsync(url, HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait(); Console.WriteLine("Received response for client.GetAsync(String, HttpCompletionOption, CancellationToken)"); client.GetAsync(new Uri(url), HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait(); Console.WriteLine("Received response for client.GetAsync(Uri, HttpCompletionOption, CancellationToken)"); } using (Tracer.Instance.StartActive("GetByteArrayAsync")) { client.GetByteArrayAsync(url).Wait(); Console.WriteLine("Received response for client.GetByteArrayAsync(String)"); client.GetByteArrayAsync(new Uri(url)).Wait(); Console.WriteLine("Received response for client.GetByteArrayAsync(Uri)"); } using (Tracer.Instance.StartActive("GetStreamAsync")) { using Stream stream1 = client.GetStreamAsync(url).Result; Console.WriteLine("Received response for client.GetStreamAsync(String)"); using Stream stream2 = client.GetStreamAsync(new Uri(url)).Result; Console.WriteLine("Received response for client.GetStreamAsync(Uri)"); } using (Tracer.Instance.StartActive("GetStringAsync")) { client.GetStringAsync(url).Wait(); Console.WriteLine("Received response for client.GetStringAsync(String)"); client.GetStringAsync(new Uri(url)).Wait(); Console.WriteLine("Received response for client.GetStringAsync(Uri)"); } #if NETCOREAPP using (Tracer.Instance.StartActive("PatchAsync")) { client.PatchAsync(url, new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PatchAsync(String, HttpContent)"); client.PatchAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PatchAsync(Uri, HttpContent)"); client.PatchAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PatchAsync(String, HttpContent, CancellationToken)"); client.PatchAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PatchAsync(Uri, HttpContent, CancellationToken)"); } #endif using (Tracer.Instance.StartActive("PostAsync")) { client.PostAsync(url, new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PostAsync(String, HttpContent)"); client.PostAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PostAsync(Uri, HttpContent)"); client.PostAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PostAsync(String, HttpContent, CancellationToken)"); client.PostAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PostAsync(Uri, HttpContent, CancellationToken)"); } using (Tracer.Instance.StartActive("PutAsync")) { client.PutAsync(url, new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PutAsync(String, HttpContent)"); client.PutAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait(); Console.WriteLine("Received response for client.PutAsync(Uri, HttpContent)"); client.PutAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PutAsync(String, HttpContent, CancellationToken)"); client.PutAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.PutAsync(Uri, HttpContent, CancellationToken)"); } using (Tracer.Instance.StartActive("SendAsync")) { client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url)).Wait(); Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage)"); client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), CancellationToken.None).Wait(); Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, CancellationToken)"); client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseContentRead).Wait(); Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, HttpCompletionOption)"); client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait(); Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, HttpCompletionOption, CancellationToken)"); } using (Tracer.Instance.StartActive("ErrorSpanBelow")) { client.GetAsync($"{url}HttpErrorCode").Wait(); Console.WriteLine("Received response for client.GetAsync Error Span"); } } } // Wait for the tasks in a single threaded synchronization context, to detect potential deadlocks var synchronizationContext = new SingleThreadedSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(synchronizationContext); synchronizationContext.Send(_ => Invoke(), null); SynchronizationContext.SetSynchronizationContext(null); }