public UserInterfaceThreadSynchronizerTest()
{
this.synchronizationContext = new TestSynchronizationContext();
this.logExtensionMock = new Mock <IUserInterfaceThreadSynchronizerLogExtension>();
this.testee = new UserInterfaceThreadSynchronizer(this.synchronizationContext, this.logExtensionMock.Object);
}
public void TestConcurrencyInThreadsAndMicrothreads()
{
var scheduler = new Scheduler();
var microThreadLock = new MicroThreadLock();
var counter = 0;
for (var j = 0; j < ThreadCount; ++j)
{
var microThread = scheduler.Create();
microThread.Start(async() =>
{
using (await microThreadLock.LockAsync())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
await Task.Yield();
++counter;
}
}
});
}
var threads = new List <Thread>();
for (var j = 0; j < ThreadCount; ++j)
{
var thread = new Thread(() =>
{
var sc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sc);
sc.Post(async x =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
for (var i = 0; i < IncrementCount; ++i)
{
Assert.AreEqual(initialValue + i, counter);
Thread.Sleep(1);
++counter;
}
}
sc.SignalEnd();
}, null);
sc.RunUntilEnd();
})
{
Name = $"Thread {j}"
};
thread.Start();
threads.Add(thread);
}
while (scheduler.MicroThreads.Count > 0)
{
scheduler.Run();
}
threads.ForEach(x => x.Join());
Assert.AreEqual(2 * ThreadCount * IncrementCount, counter);
}
public static void WaitTest()
{
var tsc = new TestSynchronizationContext();
Assert.Throws <ArgumentNullException>(() => tsc.Wait(null, false, 0));
var e = new ManualResetEvent(false);
IntPtr eventHandle = e.SafeWaitHandle.DangerousGetHandle();
var handles = new IntPtr[] { eventHandle, eventHandle };
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, false, 0));
Assert.Throws <DuplicateWaitObjectException>(() => tsc.Wait(handles, true, 0));
var e2 = new ManualResetEvent(false);
handles = new IntPtr[] { eventHandle, e2.SafeWaitHandle.DangerousGetHandle() };
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, false, 0));
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, true, 0));
e.Set();
Assert.Equal(0, tsc.Wait(handles, false, 0));
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, true, 0));
e2.Set();
Assert.Equal(0, tsc.Wait(handles, false, 0));
Assert.Equal(0, tsc.Wait(handles, true, 0));
}
public UserInterfaceThreadSynchronizerTest()
{
this.synchronizationContext = new TestSynchronizationContext();
this.logExtension = A.Fake <IUserInterfaceThreadSynchronizerLogExtension>();
this.testee = new UserInterfaceThreadSynchronizer(this.synchronizationContext, this.logExtension);
}
public UserInterfaceThreadSynchronizerTest()
{
this.synchronizationContext = new TestSynchronizationContext();
this.logExtension = A.Fake<IUserInterfaceThreadSynchronizerLogExtension>();
this.testee = new UserInterfaceThreadSynchronizer(this.synchronizationContext, this.logExtension);
}
public void SetUp()
{
_context = new TestSynchronizationContext();
_target = new SynchronizationContextCollection <string>(_context);
_collectionChanged = new List <NotifyCollectionChangedEventArgs>();
_target.CollectionChanged += (_, e) => _collectionChanged.Add(e);
}
public void Teardown()
{
this.subscriptionLogger = null;
this.synchronizationContext = null;
this.eventAggregator = null;
}
public UserInterfaceThreadSynchronizerTest()
{
this.synchronizationContext = new TestSynchronizationContext();
this.logExtensionMock = new Mock<IUserInterfaceThreadSynchronizerLogExtension>();
this.testee = new UserInterfaceThreadSynchronizer(this.synchronizationContext, this.logExtensionMock.Object);
}
public void Setup()
{
this.subscriptionLogger = new NullLogger <ISubscription>();
this.synchronizationContext = new TestSynchronizationContext();
this.eventAggregator = new EventAggregatorService(this.subscriptionLogger);
this.eventAggregator.SetMainThreadSynchronizationContext(this.synchronizationContext);
}
public void Should_properly_wrap_the_channel_as_synchronized()
{
Assert.IsNull(SynchronizationContext.Current);
var fiber = new PoolFiber();
var input = new ChannelAdapter();
var context = new TestSynchronizationContext();
var future = new Future<TestMessage>();
SynchronizationContext.SetSynchronizationContext(context);
Assert.IsNotNull(SynchronizationContext.Current);
using (input.Connect(x =>
{
x.AddConsumerOf<TestMessage>()
.OnCurrentSynchronizationContext()
.UsingConsumer(message =>
{
Trace.WriteLine("Received on Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNotNull(SynchronizationContext.Current);
Assert.AreEqual(context, SynchronizationContext.Current);
future.Complete(message);
});
}))
{
Trace.WriteLine("Subscribed on Thread: " + Thread.CurrentThread.ManagedThreadId);
SynchronizationContext.SetSynchronizationContext(null);
input.Flatten().Select(c => c.GetType()).ShouldEqual(new[]
{
typeof(ChannelAdapter),
typeof(BroadcastChannel),
typeof(TypedChannelAdapter<TestMessage>),
typeof(SynchronizedChannel<TestMessage>),
typeof(ConsumerChannel<TestMessage>),
});
fiber.Add(() =>
{
Trace.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNull(SynchronizationContext.Current);
input.Send(new TestMessage());
});
Assert.IsNull(SynchronizationContext.Current);
future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
}
public void Should_properly_wrap_the_channel_as_synchronized()
{
Assert.IsNull(SynchronizationContext.Current);
var fiber = new ThreadPoolFiber();
var input = new ChannelAdapter();
var context = new TestSynchronizationContext();
var future = new Future <TestMessage>();
SynchronizationContext.SetSynchronizationContext(context);
Assert.IsNotNull(SynchronizationContext.Current);
using (input.Connect(x =>
{
x.AddConsumerOf <TestMessage>()
.OnCurrentSynchronizationContext()
.UsingConsumer(message =>
{
Trace.WriteLine("Received on Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNotNull(SynchronizationContext.Current);
Assert.AreEqual(context, SynchronizationContext.Current);
future.Complete(message);
});
}))
{
Trace.WriteLine("Subscribed on Thread: " + Thread.CurrentThread.ManagedThreadId);
SynchronizationContext.SetSynchronizationContext(null);
input.Flatten().Select(c => c.GetType()).ShouldEqual(new[]
{
typeof(ChannelAdapter),
typeof(BroadcastChannel),
typeof(TypedChannelAdapter <TestMessage>),
typeof(SynchronizedChannel <TestMessage>),
typeof(ConsumerChannel <TestMessage>),
});
fiber.Add(() =>
{
Trace.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNull(SynchronizationContext.Current);
input.Send(new TestMessage());
});
Assert.IsNull(SynchronizationContext.Current);
future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
}
public void Teardown()
{
this.handleCounter = 0;
this.subscribeStatus = true;
this.publisherThreadSubscription = null;
this.passedEvent = null;
this.synchronizationContext = null;
SynchronizationContext.SetSynchronizationContext(null);
}
public async Task SwallowCancellation_ShouldNotCaptureContext()
{
var context = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
await Task.Run(() => throw new OperationCanceledException())
.SwallowCancellationAsync()
.ConfigureAwait(false);
Assert.False(context.IsPostCalled);
}
public async Task HandleCancellation_ShouldCaptureContextWhenSpecified()
{
var context = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
await Task.Run(() => throw new OperationCanceledException())
.HandleCancellationAsync(exception => { }, true)
.ConfigureAwait(false);
Assert.True(context.IsPostCalled);
}
public void Setup()
{
this.synchronizationContext = new TestSynchronizationContext();
this.handleAction = () => { };
this.logger = new NullLogger <ISubscription>();
SynchronizationContext.SetSynchronizationContext(this.synchronizationContext);
this.publisherThreadSubscription = new Subscription <TestEvent>(
this.logger,
e =>
{
this.passedEvent = e;
this.handleCounter++;
this.handleAction();
},
false,
EventPriority.Normal,
ThreadTarget.PublisherThread,
this.synchronizationContext,
() => this.subscribeStatus = false);
this.mainThreadSubscription = new Subscription <TestEvent>(
this.logger,
e =>
{
this.passedEvent = e;
this.handleCounter++;
this.handleAction();
},
false,
EventPriority.Normal,
ThreadTarget.MainThread,
this.synchronizationContext,
() => this.subscribeStatus = false);
this.backgroundThreadSubscription = new Subscription <TestEvent>(
this.logger,
e =>
{
this.passedEvent = e;
this.handleCounter++;
this.handleAction();
},
false,
EventPriority.Normal,
ThreadTarget.BackgroundThread,
this.synchronizationContext,
() => this.subscribeStatus = false);
}
public void CanSpecifySynchronizationContextForObservationsOnAsyncObservable()
{
var synchronizationContext = new TestSynchronizationContext();
var observable = CreateIntAsyncEnumerable().CreateAsyncObservable().ObserveOn(synchronizationContext);
var observer = CreateIntAsyncObserver();
using (observable.Subscribe(observer))
observer.WaitForCompletion();
synchronizationContext.NotifiedCount.Should().Be(StreamLength);
}
public async Task HandleException_ShouldNotCaptureContextByDefault()
{
var context = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
await Task.Run(() => throw new InvalidOperationException())
.HandleExceptionAsync <InvalidOperationException>(exception => { })
.ConfigureAwait(false);
Assert.False(context.IsPostCalled);
}
private static void CreateSetAndTest(int expectedId)
{
Assert.IsNull(SynchronizationContext.Current);
var testSyncContext = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(testSyncContext);
var currSyncContext = SynchronizationContext.Current;
Assert.IsNotNull(currSyncContext);
Assert.AreSame(testSyncContext, currSyncContext);
Assert.AreEqual(expectedId, testSyncContext.id);
}
public void TestReentrancyInThreads()
{
var microThreadLock = new MicroThreadLock();
var counter = 0;
var threads = new List <Thread>();
for (var j = 0; j < ThreadCount; ++j)
{
var thread = new Thread(() =>
{
var sc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sc);
sc.Post(async x =>
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
var initialValue = counter;
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
for (var i = 0; i < IncrementCount; ++i)
{
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
Assert.AreEqual(initialValue + i, counter);
}
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
Thread.Sleep(1);
}
using ((await microThreadLock.ReserveSyncLock()).Lock())
{
++counter;
}
}
}
}
sc.SignalEnd();
}, null);
sc.RunUntilEnd();
})
{
Name = $"Thread {j}"
};
thread.Start();
threads.Add(thread);
}
threads.ForEach(x => x.Join());
Assert.AreEqual(ThreadCount * IncrementCount, counter);
}
public async Task TestExecuteAsync_DoesNotExecuteMethodFromSameThreadWhenRunningInSynchronizationContext()
#endif
{
var reader = new Mock <IDataReader>();
var command = new Mock <IDbCommand>();
var ctx = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(ctx);
command.Setup(d => d.ExecuteReader())
.Returns(reader.Object);
reader.SetupGet(r => r.FieldCount)
.Returns(1);
var results = new[] { "Hello", ", ", "World!" };
int index = -1;
reader.Setup(r => r.Read())
.Callback(() => ++ index)
.Returns(() => index < results.Length);
reader.Setup(r => r.GetName(0))
.Returns("Id");
reader.Setup(r => r.GetString(0)).Returns((int _) => results[index]);
reader.Setup(r => r.GetFieldType(0)).Returns(typeof(string));
var connection = new Mock <IDbConnection>();
connection.Setup(c => c.CreateCommand())
.Callback(() => ctx.Worker.Should().NotBeSameAs(Thread.CurrentThread, "Command called from the same thread as the reentrant Task."))
.Returns(command.Object);
var sp = new StoredProcedure <InterfaceImpl>("foo");
var res = await sp.ExecuteAsync(connection.Object);
var idx = 0;
foreach (var toTest in res)
{
toTest.ShouldBeEquivalentTo(new InterfaceImpl {
Id = results[idx++]
});
}
SynchronizationContext.SetSynchronizationContext(null);
}
public void GlobalAddressResolverUpdateAsyncSynchronizationTest()
{
SynchronizationContext prevContext = SynchronizationContext.Current;
try
{
TestSynchronizationContext syncContext = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
syncContext.Post(_ =>
{
UserAgentContainer container = new UserAgentContainer(clientId: 0);
FakeMessageHandler messageHandler = new FakeMessageHandler();
AccountProperties databaseAccount = new AccountProperties();
Mock <IDocumentClientInternal> mockDocumentClient = new Mock <IDocumentClientInternal>();
mockDocumentClient.Setup(owner => owner.ServiceEndpoint).Returns(new Uri("https://blabla.com/"));
mockDocumentClient.Setup(owner => owner.GetDatabaseAccountInternalAsync(It.IsAny <Uri>(), It.IsAny <CancellationToken>())).ReturnsAsync(databaseAccount);
GlobalEndpointManager globalEndpointManager = new GlobalEndpointManager(mockDocumentClient.Object, new ConnectionPolicy());
GlobalPartitionEndpointManager partitionKeyRangeLocationCache = new GlobalPartitionEndpointManagerCore(globalEndpointManager);
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
RequestTimeout = TimeSpan.FromSeconds(10)
};
GlobalAddressResolver globalAddressResolver = new GlobalAddressResolver(
endpointManager: globalEndpointManager,
partitionKeyRangeLocationCache: partitionKeyRangeLocationCache,
protocol: Documents.Client.Protocol.Tcp,
tokenProvider: this.mockTokenProvider.Object,
collectionCache: null,
routingMapProvider: null,
serviceConfigReader: this.mockServiceConfigReader.Object,
connectionPolicy: connectionPolicy,
httpClient: MockCosmosUtil.CreateCosmosHttpClient(() => new HttpClient(messageHandler)));
ConnectionStateListener connectionStateListener = new ConnectionStateListener(globalAddressResolver);
connectionStateListener.OnConnectionEvent(ConnectionEvent.ReadEof, DateTime.Now, new Documents.Rntbd.ServerKey(new Uri("https://endpoint.azure.com:4040/")));
}, state: null);
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevContext);
}
}
public async Task ContextualAsyncTest()
{
var syncContext = new TestSynchronizationContext();
var scheduler = FutureScheduler.FromSynchronizationContext(syncContext);
async ContextualFuture LocalTest()
{
syncContext.AssertCurrentContext();
await LocalTest2();
}
async Future LocalTest2()
{
await FutureScheduler.ThreadPool;
Assert.Null(SynchronizationContext.Current);
}
await scheduler.Run(() => LocalTest());
}
public void Calls_WhenError_via_SynchronizationContext()
{
var sc = new TestSynchronizationContext();
var whenErrorWasCalled = false;
var workerAction = WorkerAction.Define()
.DoWork(delegate
{
throw new ApplicationException("Test exception");
})
.WhenError(delegate
{
Assert.IsTrue(sc.IsInSend);
whenErrorWasCalled = true;
})
.Create();
workerAction.SynchronizationContext = sc;
workerAction.Run();
Assert.IsTrue(whenErrorWasCalled, "WhenError was not called");
}
public static void WaitNotificationTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var tsc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(tsc);
Assert.Same(tsc, SynchronizationContext.Current);
var e = new ManualResetEvent(false);
tsc.WaitAction = () => e.Set();
Assert.False(tsc.IsWaitNotificationRequired());
Assert.False(e.WaitOne(0));
tsc.SetWaitNotificationRequired();
Assert.True(tsc.IsWaitNotificationRequired());
Assert.True(e.WaitOne(0));
var mres = new ManualResetEventSlim();
tsc.WaitAction = () => mres.Set();
mres.Reset();
mres.CheckedWait();
e.Reset();
tsc.WaitAction = () => e.Set();
SynchronizationContext.SetSynchronizationContext(new TestSynchronizationContext());
Assert.False(e.WaitOne(0));
SynchronizationContext.SetSynchronizationContext(tsc);
Assert.True(e.WaitOne(0));
e.Reset();
e.CheckedWait();
e.Reset();
var lockObj = new object();
var lockAcquiredFromBackground = new AutoResetEvent(false);
Action waitForThread;
Thread t =
ThreadTestHelpers.CreateGuardedThread(out waitForThread, () =>
{
lock (lockObj)
{
lockAcquiredFromBackground.Set();
e.CheckedWait();
}
});
t.IsBackground = true;
t.Start();
lockAcquiredFromBackground.CheckedWait();
Assert.True(Monitor.TryEnter(lockObj, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
Monitor.Exit(lockObj);
waitForThread();
e.Reset();
var m = new Mutex();
t = ThreadTestHelpers.CreateGuardedThread(out waitForThread, () =>
{
m.CheckedWait();
try
{
lockAcquiredFromBackground.Set();
e.CheckedWait();
}
finally
{
m.ReleaseMutex();
}
});
t.IsBackground = true;
t.Start();
lockAcquiredFromBackground.CheckedWait();
m.CheckedWait();
m.ReleaseMutex();
waitForThread();
});
}
public ScreenViewTests()
{
_terminal = new TestTerminal();
_renderer = new ConsoleRenderer(_terminal);
_synchronizationContext = new TestSynchronizationContext();
}
public void TearDown()
{
_target = null;
_context = null;
}
[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)] // desktop framework does not check for null and crashes
public static void WaitTest_ChangedInDotNetCore()
{
Assert.Throws <ArgumentNullException>(() => TestSynchronizationContext.WaitHelper(null, false, 0));
}
public ScreenViewTests()
{
_console = new TestConsole();
_renderer = new ConsoleRenderer(_console);
_synchronizationContext = new TestSynchronizationContext();
}
public void VerifySynchronizationContextDoesNotLock()
{
string databaseId = Guid.NewGuid().ToString();
SynchronizationContext prevContext = SynchronizationContext.Current;
try
{
TestSynchronizationContext syncContext = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
syncContext.Post(_ =>
{
using (CosmosClient client = TestCommon.CreateCosmosClient())
{
Cosmos.Database database = client.CreateDatabaseAsync(databaseId).GetAwaiter().GetResult();
database = client.CreateDatabaseIfNotExistsAsync(databaseId).GetAwaiter().GetResult();
database.ReadStreamAsync().ConfigureAwait(false).GetAwaiter().GetResult();
database.ReadAsync().ConfigureAwait(false).GetAwaiter().GetResult();
QueryDefinition databaseQuery = new QueryDefinition("select * from T where T.id = @id").WithParameter("@id", databaseId);
FeedIterator <DatabaseProperties> databaseIterator = client.GetDatabaseQueryIterator <DatabaseProperties>(databaseQuery);
while (databaseIterator.HasMoreResults)
{
databaseIterator.ReadNextAsync().GetAwaiter().GetResult();
}
Container container = database.CreateContainerAsync(Guid.NewGuid().ToString(), "/pk").GetAwaiter().GetResult();
container = database.CreateContainerIfNotExistsAsync(container.Id, "/pk").GetAwaiter().GetResult();
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = container.CreateItemAsync <ToDoActivity>(item: testItem).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.IsNotNull(response);
string diagnostics = response.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("SynchronizationContext"));
using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
try
{
ToDoActivity tempItem = ToDoActivity.CreateRandomToDoActivity();
CancellationToken cancellationToken = cancellationTokenSource.Token;
cancellationTokenSource.Cancel();
container.CreateItemAsync <ToDoActivity>(item: tempItem, cancellationToken: cancellationToken).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.Fail("Should have thrown a cancellation token");
}catch (CosmosOperationCanceledException oe)
{
string exception = oe.ToString();
Assert.IsTrue(exception.Contains("SynchronizationContext"));
}
// Test read feed
container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
requestOptions: new QueryRequestOptions()
{
}).ToList();
FeedIterator feedIterator = container.GetItemLinqQueryable <ToDoActivity>()
.ToStreamIterator();
while (feedIterator.HasMoreResults)
{
feedIterator.ReadNextAsync().GetAwaiter().GetResult();
}
FeedIterator <ToDoActivity> feedIteratorTyped = container.GetItemLinqQueryable <ToDoActivity>()
.ToFeedIterator <ToDoActivity>();
while (feedIteratorTyped.HasMoreResults)
{
feedIteratorTyped.ReadNextAsync().GetAwaiter().GetResult();
}
// Test query
container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
requestOptions: new QueryRequestOptions()
{
}).Where(item => item.id != "").ToList();
FeedIterator queryIterator = container.GetItemLinqQueryable <ToDoActivity>()
.Where(item => item.id != "").ToStreamIterator();
while (queryIterator.HasMoreResults)
{
queryIterator.ReadNextAsync().GetAwaiter().GetResult();
}
FeedIterator <ToDoActivity> queryIteratorTyped = container.GetItemLinqQueryable <ToDoActivity>()
.Where(item => item.id != "").ToFeedIterator <ToDoActivity>();
while (queryIteratorTyped.HasMoreResults)
{
queryIteratorTyped.ReadNextAsync().GetAwaiter().GetResult();
}
double costAsync = container.GetItemLinqQueryable <ToDoActivity>()
.Select(x => x.cost).SumAsync().GetAwaiter().GetResult();
double cost = container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true).Select(x => x.cost).Sum();
ItemResponse <ToDoActivity> deleteResponse = container.DeleteItemAsync <ToDoActivity>(partitionKey: new Cosmos.PartitionKey(testItem.pk), id: testItem.id).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.IsNotNull(deleteResponse);
}
}, state: null);
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevContext);
using (CosmosClient client = TestCommon.CreateCosmosClient())
{
client.GetDatabase(databaseId).DeleteAsync().GetAwaiter().GetResult();
}
}
}
public void Uses_synchronization_context_for_response()
{
int result = 0;
bool wasInSend = false;
var sc = new TestSynchronizationContext();
_client1.SynchronizationContext = sc;
_client2.CreateSubscriber<Request>()
.WithAction(request => _client2.Reply(new Response1 {Number = request.Number}))
.AddTo(_disposables);
var channel = _client1.CreateChannel()
.HandleResponse<Response1>(response =>
{
wasInSend = sc.IsInSend;
result = response.Number;
_waitEvent.Set();
})
.AddTo(_disposables);
// This is lame -- need to have an action when the subscription is ready
Thread.Sleep(500);
channel.Send(new Request {Number = 42});
_waitEvent.WaitOne();
Assert.AreEqual(42, result);
Assert.IsTrue(wasInSend);
}
public static void WaitNotificationTest()
{
ThreadTestHelpers.RunTestInBackgroundThread(() =>
{
var tsc = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(tsc);
Assert.Same(tsc, SynchronizationContext.Current);
var e = new ManualResetEvent(false);
tsc.WaitAction = () => e.Set();
Assert.False(tsc.IsWaitNotificationRequired());
Assert.False(e.WaitOne(0));
tsc.SetWaitNotificationRequired();
Assert.True(tsc.IsWaitNotificationRequired());
Assert.True(e.WaitOne(0));
var mres = new ManualResetEventSlim();
tsc.WaitAction = () => mres.Set();
mres.Reset();
mres.CheckedWait();
e.Reset();
tsc.WaitAction = () => e.Set();
SynchronizationContext.SetSynchronizationContext(new TestSynchronizationContext());
Assert.False(e.WaitOne(0));
SynchronizationContext.SetSynchronizationContext(tsc);
Assert.True(e.WaitOne(0));
e.Reset();
e.CheckedWait();
e.Reset();
var lockObj = new object();
var lockAcquiredFromBackground = new AutoResetEvent(false);
Action waitForThread;
Thread t =
ThreadTestHelpers.CreateGuardedThread(out waitForThread, () =>
{
lock (lockObj)
{
lockAcquiredFromBackground.Set();
e.CheckedWait();
}
});
t.IsBackground = true;
t.Start();
lockAcquiredFromBackground.CheckedWait();
Assert.True(Monitor.TryEnter(lockObj, ThreadTestHelpers.UnexpectedTimeoutMilliseconds));
Monitor.Exit(lockObj);
waitForThread();
e.Reset();
var m = new Mutex();
t = ThreadTestHelpers.CreateGuardedThread(out waitForThread, () =>
{
m.CheckedWait();
try
{
lockAcquiredFromBackground.Set();
e.CheckedWait();
}
finally
{
m.ReleaseMutex();
}
});
t.IsBackground = true;
t.Start();
lockAcquiredFromBackground.CheckedWait();
m.CheckedWait();
m.ReleaseMutex();
waitForThread();
});
}
public static void WaitTest()
{
var tsc = new TestSynchronizationContext();
Assert.Throws<ArgumentNullException>(() => tsc.Wait(null, false, 0));
var e = new ManualResetEvent(false);
IntPtr eventHandle = e.SafeWaitHandle.DangerousGetHandle();
var handles = new IntPtr[] { eventHandle, eventHandle };
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, false, 0));
Assert.Throws<DuplicateWaitObjectException>(() => tsc.Wait(handles, true, 0));
var e2 = new ManualResetEvent(false);
handles = new IntPtr[] { eventHandle, e2.SafeWaitHandle.DangerousGetHandle() };
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, false, 0));
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, true, 0));
e.Set();
Assert.Equal(0, tsc.Wait(handles, false, 0));
Assert.Equal(WaitHandle.WaitTimeout, tsc.Wait(handles, true, 0));
e2.Set();
Assert.Equal(0, tsc.Wait(handles, false, 0));
Assert.Equal(0, tsc.Wait(handles, true, 0));
}
private void SetupSynchronizationContext()
{
_synchronizationContext = new TestSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(_synchronizationContext);
this._testInstance = new FileUploadController();
}
public void Uses_synchronization_context_for_timeout()
{
bool timedOut = false;
var sc = new TestSynchronizationContext();
_client1.SynchronizationContext = sc;
var channel = _client1.CreateChannel()
.HandleTimeout(1, () =>
{
Assert.IsTrue(sc.IsInSend);
timedOut = true;
_waitEvent.Set();
})
.AddTo(_disposables);
channel.Send(new Request {Number = 999});
_waitEvent.WaitOne(3000);
Assert.IsTrue(timedOut);
}
public void Starting_and_Stopped_event_called_with_two_actions_and_with_SynchronizationContext()
{
var sc = new TestSynchronizationContext();
_worker.SynchronizationContext = sc;
var counter = 0;
var startingRaised = 0;
var stoppedRaised = 0;
var doWork1Called = 0;
var whenComplete1Called = 0;
var doWorkWaitHandle1 = new ManualResetEvent(false);
var doWork2Called = 0;
var whenComplete2Called = 0;
var doWorkWaitHandle2 = new ManualResetEvent(false);
var completeWaitHandle = new ManualResetEvent(false);
var stoppedRaisedWaitHandle = new ManualResetEvent(false);
_worker.Starting += delegate
{
Assert.IsTrue(sc.IsInSend);
startingRaised = Interlocked.Increment(ref counter);
};
_worker.Stopped += delegate
{
Assert.IsTrue(sc.IsInSend);
stoppedRaised = Interlocked.Increment(ref counter);
stoppedRaisedWaitHandle.Set();
completeWaitHandle.WaitOne();
};
// start one worker
WorkerAction.Define()
.DoWork(delegate
{
doWork1Called = Interlocked.Increment(ref counter);
doWorkWaitHandle1.Set();
completeWaitHandle.WaitOne();
})
.WhenComplete(delegate
{
Assert.IsTrue(sc.IsInSend);
whenComplete1Called = ++counter;
})
.Run(_worker);
// wait for the worker to start
doWorkWaitHandle1.WaitOne();
Assert.AreEqual(1, startingRaised);
Assert.AreEqual(2, doWork1Called);
Assert.AreEqual(0, stoppedRaised);
// start another work action while the first one is still running
WorkerAction.Define()
.DoWork(delegate
{
doWork2Called = Interlocked.Increment(ref counter);
doWorkWaitHandle2.Set();
})
.WhenComplete(delegate
{
Assert.IsTrue(sc.IsInSend);
whenComplete2Called = ++counter;
})
.Run(_worker);
doWorkWaitHandle2.WaitOne();
Assert.AreEqual(1, startingRaised); // did not get called again
Assert.AreEqual(2, doWork1Called);
Assert.AreEqual(3, doWork2Called);
Assert.AreEqual(0, stoppedRaised);
completeWaitHandle.Set();
stoppedRaisedWaitHandle.WaitOne();
Assert.AreEqual(1, startingRaised); // did not get called again
Assert.AreEqual(2, doWork1Called);
Assert.AreEqual(3, doWork2Called);
// one should be 4 and one should be 5, but they could be either order
Assert.AreEqual(9, whenComplete1Called + whenComplete2Called);
Assert.AreEqual(6, stoppedRaised);
}
public void Calls_WhenComplete_via_SynchronizationContext()
{
var sc = new TestSynchronizationContext();
bool doWorkWasRun = false;
bool whenCompleteWasRun = false;
var action = WorkerAction.Define()
.DoWork(delegate
{
// Verifies that this is not being called
// via the SynchronizationContext
Assert.IsFalse(sc.IsInSend);
doWorkWasRun = true;
return 2 + 2;
})
.WhenComplete(delegate(int n)
{
Assert.IsTrue(sc.IsInSend);
Assert.AreEqual(4, n);
whenCompleteWasRun = true;
})
.WhenError(ex => Assert.Fail("When error called"))
.Create();
action.SynchronizationContext = sc;
action.Run();
Assert.IsTrue(doWorkWasRun);
Assert.IsTrue(whenCompleteWasRun);
}
