public void ReentrancyPostAndWaitTest()
{
int actionCallCount = 0;
int innerActionCallCount = 0;
using (var context = UnitTestSynchronizationContext.Create())
{
Func <Task> asyncInnerAction = async() =>
{
await Task.Delay(1);
Interlocked.Increment(ref innerActionCallCount);
};
Func <Task> asyncAction = async() =>
{
await Task.Delay(1);
asyncInnerAction().Wait(context);
await Task.Delay(1);
asyncInnerAction().Wait(context);
Interlocked.Increment(ref actionCallCount);
};
var task = asyncAction();
Assert.AreEqual(0, actionCallCount);
Assert.AreEqual(0, innerActionCallCount);
task.Wait(context);
Assert.AreEqual(1, actionCallCount);
Assert.AreEqual(2, innerActionCallCount);
}
}
public void PostAndWaitTest()
{
int actionCallCount = 0;
var context = UnitTestSynchronizationContext.Create();
Func <Task> asyncAction = async() =>
{
await Task.Delay(1);
Interlocked.Increment(ref actionCallCount);
};
var task = asyncAction();
Assert.AreEqual(0, actionCallCount);
task.Wait(context);
Assert.AreEqual(1, actionCallCount);
task = asyncAction();
context.Wait(TimeSpan.FromMilliseconds(50));
Assert.AreEqual(2, actionCallCount);
context.Dispose();
Assert.AreEqual(2, actionCallCount);
}
public void WaitForTest()
{
using (var context = UnitTestSynchronizationContext.Create())
{
bool flag = false;
Action asyncAction = async() =>
{
await Task.Delay(10);
flag = true;
};
asyncAction();
Assert.IsFalse(flag);
context.WaitFor(() => flag, TimeSpan.FromSeconds(1));
Assert.IsTrue(flag);
AssertHelper.ExpectedException <TimeoutException>(() => context.WaitFor(() => !flag, TimeSpan.FromMilliseconds(10)));
AssertHelper.ExpectedException <ArgumentNullException>(() => UnitTestSynchronizationContextExtensions.WaitFor(context, null, TimeSpan.FromMilliseconds(10)));
}
AssertHelper.ExpectedException <ArgumentNullException>(() => UnitTestSynchronizationContextExtensions.WaitFor(null, () => true, TimeSpan.FromMilliseconds(10)));
}
public void Should_Return_BindingNotification_If_Stream_Operator_Applied_To_Not_Supported_Type()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new Class2("foo");
var target = new ExpressionObserver(data, "Foo^", true);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
sync.ExecutePostedCallbacks();
Assert.Equal(
new[]
{
new BindingNotification(
new MarkupBindingChainException("Stream operator applied to unsupported type", "Foo^", "Foo^"),
BindingErrorType.Error)
},
result);
sub.Dispose();
GC.KeepAlive(data);
}
}
public void Should_Return_BindingNotification_Error_On_Task_Exception()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <string>();
var data = new { Foo = tcs.Task };
var target = ExpressionObserver.Create(data, o => o.Foo.StreamBinding());
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetException(new NotSupportedException());
sync.ExecutePostedCallbacks();
Assert.Equal(
new[]
{
new BindingNotification(
new AggregateException(new NotSupportedException()),
BindingErrorType.Error)
},
result);
GC.KeepAlive(data);
}
}
public void Should_Get_Property_Value_From_Observable_With_DataValidation_Enabled()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data1 = new Class1();
var data2 = new Class2("foo");
var target = ExpressionObserver.Create(data1, o => o.Next.StreamBinding().Foo, true);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
data1.Next.OnNext(data2);
sync.ExecutePostedCallbacks();
// Forces WeakEvent compact
Dispatcher.UIThread.RunJobs();
Assert.Equal(new[] { new BindingNotification("foo") }, result);
sub.Dispose();
// Forces WeakEvent compact
Dispatcher.UIThread.RunJobs();
Assert.Equal(0, data1.PropertyChangedSubscriptionCount);
GC.KeepAlive(data1);
GC.KeepAlive(data2);
}
}
public void PostAndWaitExceptionTest()
{
using (var context = UnitTestSynchronizationContext.Create())
{
AssertHelper.ExpectedException <ArgumentNullException>(() => context.Post(null, null));
AssertHelper.ExpectedException <ArgumentNullException>(() => context.Wait(null));
}
}
protected override void OnInitialize()
{
base.OnInitialize();
Context = UnitTestSynchronizationContext.Create();
var configuration = new ContainerConfiguration()
.WithAssembly(typeof(ShellViewModel).GetTypeInfo().Assembly)
.WithAssembly(typeof(ApplicationsTest).GetTypeInfo().Assembly);
Container = configuration.CreateContainer();
}
public void Should_Get_Completed_Task_Value()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new { Foo = Task.FromResult("foo") };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
Assert.Equal(new object[] { "foo" }, result.ToArray());
}
}
public void SendTest()
{
int actionCallCount = 0;
var context = UnitTestSynchronizationContext.Create();
context.Send(state => actionCallCount++, null);
Assert.AreEqual(1, actionCallCount);
AssertHelper.ExpectedException <ArgumentNullException>(() => context.Send(null, null));
context.Dispose();
context.Send(state => actionCallCount++, null);
Assert.AreEqual(1, actionCallCount);
}
public void Should_Get_Completed_Task_Value()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new { Foo = Task.FromResult("foo") };
var target = ExpressionObserver.Create(data, o => o.Foo.StreamBinding());
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
Assert.Equal(new[] { "foo" }, result);
GC.KeepAlive(data);
}
}
public void Should_Get_Simple_Observable_Value()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var source = new BehaviorSubject <string>("foo");
var data = new { Foo = source };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
source.OnNext("bar");
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { PerspexProperty.UnsetValue, "foo", "bar" }, result);
}
}
public void Should_Not_Get_Observable_Value_Without_Modifier_Char()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var source = new BehaviorSubject <string>("foo");
var data = new { Foo = source };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
source.OnNext("bar");
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { source }, result);
}
}
public void Should_Get_Simple_Task_Value()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <string>();
var data = new { Foo = tcs.Task };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult("foo");
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { "foo" }, result);
}
}
public void Should_Get_Property_Value_From_Task()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <Class2>();
var data = new Class1(tcs.Task);
var target = new ExpressionObserver(data, "Next.Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult(new Class2("foo"));
sync.ExecutePostedCallbacks();
Assert.Equal(new object[] { PerspexProperty.UnsetValue, "foo" }, result.ToArray());
}
}
public void Should_Not_Get_Task_Result_Without_Modifier_Char()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <string>();
var data = new { Foo = tcs.Task };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult("foo");
sync.ExecutePostedCallbacks();
Assert.Equal(1, result.Count);
Assert.IsType <Task <string> >(result[0]);
}
}
protected override void OnInitialize()
{
base.OnInitialize();
context = UnitTestSynchronizationContext.Create();
catalog = new AggregateCatalog();
OnCatalogInitialize(catalog);
container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
ShellService shellService = Container.GetExportedValue<ShellService>();
shellService.Settings = new AppSettings();
}
public void Should_Get_Property_Value_From_Task()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <Class2>();
var data = new Class1(tcs.Task);
var target = ExpressionObserver.Create(data, o => o.Next.StreamBinding().Foo);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult(new Class2("foo"));
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { "foo" }, result);
GC.KeepAlive(data);
}
}
public void Should_Get_Simple_Observable_Value()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var source = new BehaviorSubject <string>("foo");
var data = new { Foo = source };
var target = ExpressionObserver.Create(data, o => o.Foo.StreamBinding());
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
source.OnNext("bar");
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { "foo", "bar" }, result);
GC.KeepAlive(data);
}
}
public void Should_Get_Simple_Observable_Value_With_DataValidation_Enabled()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var source = new BehaviorSubject <string>("foo");
var data = new { Foo = source };
var target = new ExpressionObserver(data, "Foo", true);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
source.OnNext("bar");
sync.ExecutePostedCallbacks();
// What does it mean to have data validation on an observable? Without a use-case
// it's hard to know what to do here so for the moment the value is returned.
Assert.Equal(new[] { "foo", "bar" }, result);
}
}
public void Should_Work_With_Value_Type()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var source = new BehaviorSubject <int>(1);
var data = new { Foo = source };
var target = ExpressionObserver.Create(data, o => o.Foo.StreamBinding());
var result = new List <int>();
var sub = target.Subscribe(x => result.Add((int)x));
source.OnNext(42);
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { 1, 42 }, result);
GC.KeepAlive(data);
}
}
public void Should_Get_Simple_Task_Value_With_Data_DataValidation_Enabled()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <string>();
var data = new { Foo = tcs.Task };
var target = new ExpressionObserver(data, "Foo", true);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult("foo");
sync.ExecutePostedCallbacks();
// What does it mean to have data validation on a Task? Without a use-case it's
// hard to know what to do here so for the moment the value is returned.
Assert.Equal(new [] { "foo" }, result);
}
}
public void Should_Get_Property_Value_From_Observable()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new Class1();
var target = new ExpressionObserver(data, "Next.Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
data.Next.OnNext(new Class2("foo"));
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { PerspexProperty.UnsetValue, "foo" }, result);
sub.Dispose();
Assert.Equal(0, data.SubscriptionCount);
}
}
public void Should_Get_Property_Value_From_Observable_With_DataValidation_Enabled()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new Class1();
var target = new ExpressionObserver(data, "Next.Foo", true);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
data.Next.OnNext(new Class2("foo"));
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { new BindingNotification("foo") }, result);
sub.Dispose();
Assert.Equal(0, data.PropertyChangedSubscriptionCount);
}
}
public void Should_Not_Get_Task_Result_Without_StreamBinding()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var tcs = new TaskCompletionSource <string>();
var data = new { Foo = tcs.Task };
var target = ExpressionObserver.Create(data, o => o.Foo);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
tcs.SetResult("foo");
sync.ExecutePostedCallbacks();
Assert.Single(result);
Assert.IsType <Task <string> >(result[0]);
GC.KeepAlive(data);
}
}
public void CreateAndDisposingTest()
{
Assert.IsNull(SynchronizationContext.Current);
using (var context = UnitTestSynchronizationContext.Create())
{
Assert.AreEqual(context, SynchronizationContext.Current);
Assert.AreEqual(context, UnitTestSynchronizationContext.Current);
using (var nestedContext = (UnitTestSynchronizationContext)context.CreateCopy())
{
SynchronizationContext.SetSynchronizationContext(nestedContext);
Assert.AreEqual(nestedContext, SynchronizationContext.Current);
Assert.AreEqual(nestedContext, UnitTestSynchronizationContext.Current);
}
Assert.AreEqual(context, SynchronizationContext.Current);
}
Assert.IsNull(SynchronizationContext.Current);
}
public void Should_Return_BindingNotification_Error_For_Faulted_Task()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new { Foo = TaskFromException(new NotSupportedException()) };
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
Assert.Equal(
new[]
{
new BindingNotification(
new AggregateException(new NotSupportedException()),
BindingErrorType.Error)
},
result);
}
}
public void Should_Get_Property_Value_From_Observable()
{
using (var sync = UnitTestSynchronizationContext.Begin())
{
var data = new Class1();
var target = ExpressionObserver.Create(data, o => o.Next.StreamBinding().Foo);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
data.Next.OnNext(new Class2("foo"));
sync.ExecutePostedCallbacks();
Assert.Equal(new[] { "foo" }, result);
sub.Dispose();
Assert.Equal(0, data.PropertyChangedSubscriptionCount);
GC.KeepAlive(data);
}
}
protected override void OnInitialize()
{
base.OnInitialize();
context = UnitTestSynchronizationContext.Create();
catalog = new AggregateCatalog();
OnCatalogInitialize(catalog);
container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
ShellService shellService = Container.GetExportedValue <ShellService>();
shellService.Settings = new AppSettings();
ServiceLocator.RegisterInstance <IChangeTrackerService>(new ChangeTrackerService());
}
public void WaitTest()
{
using (var context = UnitTestSynchronizationContext.Create())
{
int actionCallCount = 0;
Func <Task <int> > asyncAction = async() =>
{
await Task.Delay(1);
Interlocked.Increment(ref actionCallCount);
return(actionCallCount);
};
var task = asyncAction();
Assert.AreEqual(0, actionCallCount);
task.Wait(context);
Assert.AreEqual(1, actionCallCount);
}
AssertHelper.ExpectedException <ArgumentNullException>(() => UnitTestSynchronizationContextExtensions.Wait(Task.FromResult((object)null), null));
}
public void InvokeMaxEveryDelayTimeTestWithSynchronizationContext()
{
using var context = UnitTestSynchronizationContext.Create();
int actionCallCount = 0;
var throttledAction = new ThrottledAction(() => Interlocked.Add(ref actionCallCount, 1), ThrottledActionMode.InvokeMaxEveryDelayTime, TimeSpan.FromMilliseconds(100));
Assert.IsFalse(throttledAction.IsRunning);
throttledAction.InvokeAccumulated();
Assert.IsTrue(throttledAction.IsRunning);
throttledAction.InvokeAccumulated();
throttledAction.InvokeAccumulated();
// As long the unit test synchronization context is not executed the actionCallCount must not be increased.
Task.Delay(200).Wait();
Assert.AreEqual(0, actionCallCount);
// Execute the unit test synchronization context.
context.WaitFor(() => actionCallCount > 0, TimeSpan.FromMilliseconds(200));
Assert.AreEqual(1, actionCallCount);
Assert.IsFalse(throttledAction.IsRunning);
}
