public void Should_Set_Node_Target_To_Null_On_Unsubscribe()
{
var target = new ExpressionObserver(new { Foo = "foo" }, "Foo");
var result = new List<object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
Assert.NotNull(target.Node.Target);
}
Assert.Equal(new[] { "foo" }, result);
Assert.Null(target.Node.Target);
}
public void Should_Set_Node_Target_To_Null_On_Unsubscribe()
{
var target = new ExpressionObserver(new { Foo = "foo" }, "Foo");
var result = new List <object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
Assert.NotNull(target.Node.Target);
}
Assert.Equal(new[] { "foo" }, result);
Assert.Null(target.Node.Target);
}
public void Should_Track_Property_Chain_Changing()
{
var data = new Class1 {
Next = new Class2 {
Bar = "bar"
}
};
var target = new ExpressionObserver(data, "Next.Bar");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
var old = data.Next;
data.Next = new Class2 {
Bar = "baz"
};
data.Next = new Class2 {
Bar = null
};
Assert.Equal(new[] { "bar", "baz", null }, result);
sub.Dispose();
Assert.Equal(0, data.PropertyChangedSubscriptionCount);
Assert.Equal(0, data.Next.PropertyChangedSubscriptionCount);
Assert.Equal(0, old.PropertyChangedSubscriptionCount);
GC.KeepAlive(data);
}
public void Can_Replace_Root()
{
var first = new Class1 {
Foo = "foo"
};
var second = new Class1 {
Foo = "bar"
};
var root = first;
var update = new Subject <Unit>();
var target = new ExpressionObserver(() => root, "Foo", update);
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
root = second;
update.OnNext(Unit.Default);
root = null;
update.OnNext(Unit.Default);
Assert.Equal(
new object[]
{
"foo",
"bar",
AvaloniaProperty.UnsetValue,
},
result);
Assert.Equal(0, first.PropertyChangedSubscriptionCount);
Assert.Equal(0, second.PropertyChangedSubscriptionCount);
GC.KeepAlive(first);
GC.KeepAlive(second);
}
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_Trigger_PropertyChanged_On_Null_Or_Empty_String()
{
var data = new Class1 {
Bar = "foo"
};
var target = new ExpressionObserver(data, "Bar");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
Assert.Equal(new[] { "foo" }, result);
data.Bar = "bar";
Assert.Equal(new[] { "foo" }, result);
data.RaisePropertyChanged(string.Empty);
Assert.Equal(new[] { "foo", "bar" }, result);
data.RaisePropertyChanged(null);
Assert.Equal(new[] { "foo", "bar", "bar" }, result);
sub.Dispose();
Assert.Equal(0, data.PropertyChangedSubscriptionCount);
GC.KeepAlive(data);
}
public void Should_Track_Property_Chain_Breaking_With_Object_Then_Mending()
{
var data = new Class1 {
Next = new Class2 {
Bar = "bar"
}
};
var target = new ExpressionObserver(data, "Next.Bar");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
var old = data.Next;
var breaking = new WithoutBar();
data.Next = breaking;
data.Next = new Class2 {
Bar = "baz"
};
Assert.Equal(3, result.Count);
Assert.Equal("bar", result[0]);
Assert.IsType <BindingError>(result[1]);
Assert.Equal("baz", result[2]);
sub.Dispose();
Assert.Equal(0, data.SubscriptionCount);
Assert.Equal(0, data.Next.SubscriptionCount);
Assert.Equal(0, breaking.SubscriptionCount);
Assert.Equal(0, old.SubscriptionCount);
}
public void Should_Unsubscribe_From_Update_Observable()
{
var scheduler = new TestScheduler();
var update = scheduler.CreateColdObservable<Unit>();
var target = new ExpressionObserver(() => new { Foo = "foo" }, "Foo", update);
var result = new List<object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
scheduler.Start();
}
Assert.Equal(new[] { "foo" }, result);
Assert.All(update.Subscriptions, x => Assert.NotEqual(Subscription.Infinite, x.Unsubscribe));
}
public void Should_Track_Property_Chain_Breaking_With_Object_Then_Mending()
{
var data = new Class1 {
Next = new Class2 {
Bar = "bar"
}
};
var target = new ExpressionObserver(data, "Next.Bar");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
var old = data.Next;
var breaking = new WithoutBar();
data.Next = breaking;
data.Next = new Class2 {
Bar = "baz"
};
Assert.Equal(new[] { "bar", PerspexProperty.UnsetValue, "baz" }, result);
sub.Dispose();
Assert.Equal(0, data.SubscriptionCount);
Assert.Equal(0, data.Next.SubscriptionCount);
Assert.Equal(0, breaking.SubscriptionCount);
Assert.Equal(0, old.SubscriptionCount);
}
public void Should_Unsubscribe_From_Update_Observable()
{
var scheduler = new TestScheduler();
var update = scheduler.CreateColdObservable <Unit>();
var target = new ExpressionObserver(() => new { Foo = "foo" }, "Foo", update);
var result = new List <object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
scheduler.Start();
}
Assert.Equal(new[] { "foo" }, result);
Assert.All(update.Subscriptions, x => Assert.NotEqual(Subscription.Infinite, x.Unsubscribe));
}
public void Validation_Plugins_Send_Correct_Notifications()
{
var data = new IndeiTest();
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), true);
var result = new List<object>();
observer.Subscribe(x => result.Add(x));
observer.SetValue(5);
observer.SetValue(-5);
observer.SetValue("foo");
observer.SetValue(5);
Assert.Equal(new[]
{
new BindingNotification(0),
// Value is notified twice as ErrorsChanged is always called by IndeiTest.
new BindingNotification(5),
new BindingNotification(5),
// Value is first signalled without an error as validation hasn't been updated.
new BindingNotification(-5),
new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, -5),
// Exception is thrown by trying to set value to "foo".
new BindingNotification(
new ArgumentException("Object of type 'System.String' cannot be converted to type 'System.Int32'."),
BindingErrorType.DataValidationError),
// Value is set then validation is updated.
new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, 5),
new BindingNotification(5),
}, result);
}
public void Validation_Plugins_Send_Correct_Notifications()
{
var data = new IndeiTest();
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), true);
var result = new List <object>();
observer.Subscribe(x => result.Add(x));
observer.SetValue(5);
observer.SetValue(-5);
observer.SetValue("foo");
observer.SetValue(5);
Assert.Equal(new[]
{
new BindingNotification(0),
// Value is notified twice as ErrorsChanged is always called by IndeiTest.
new BindingNotification(5),
new BindingNotification(5),
// Value is first signalled without an error as validation hasn't been updated.
new BindingNotification(-5),
new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, -5),
// Exception is thrown by trying to set value to "foo".
new BindingNotification(
new ArgumentException("Object of type 'System.String' cannot be converted to type 'System.Int32'."),
BindingErrorType.DataValidationError),
// Value is set then validation is updated.
new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, 5),
new BindingNotification(5),
}, result);
}
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 = new ExpressionObserver(data, "Foo^");
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_Unsubscribe_From_Source_Observable()
{
var scheduler = new TestScheduler();
var source = scheduler.CreateColdObservable(
OnNext(1, new { Foo = "foo" }));
var target = new ExpressionObserver(source, "Foo");
var result = new List <object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
scheduler.Start();
}
Assert.Equal(new[] { AvaloniaProperty.UnsetValue, "foo" }, result);
Assert.All(source.Subscriptions, x => Assert.NotEqual(Subscription.Infinite, x.Unsubscribe));
}
public void Subscribing_Multiple_Times_Should_Only_Add_PropertyChanged_Handlers_Once()
{
var data = new Class1 {
Foo = "foo"
};
var target = new ExpressionObserver(data, "Foo");
var sub1 = target.Subscribe(x => { });
var sub2 = target.Subscribe(x => { });
Assert.Equal(1, data.PropertyChangedSubscriptionCount);
sub1.Dispose();
sub2.Dispose();
Assert.Equal(0, data.PropertyChangedSubscriptionCount);
}
public void Should_Unsubscribe_From_Source_Observable()
{
var scheduler = new TestScheduler();
var source = scheduler.CreateColdObservable(
OnNext(1, new { Foo = "foo" }));
var target = new ExpressionObserver(source, "Foo");
var result = new List<object>();
using (target.Subscribe(x => result.Add(x)))
using (target.Subscribe(_ => { }))
{
scheduler.Start();
}
Assert.Equal(new[] { AvaloniaProperty.UnsetValue, "foo" }, result);
Assert.All(source.Subscriptions, x => Assert.NotEqual(Subscription.Infinite, x.Unsubscribe));
}
public void Indei_Validation_Does_Not_Subscribe_When_DataValidatation_Not_Enabled()
{
var data = new IndeiTest { MustBePositive = 5 };
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), false);
observer.Subscribe(_ => { });
Assert.Equal(0, data.ErrorsChangedSubscriptionCount);
}
public void Should_Get_Simple_Property_Value_Type()
{
var data = new { Foo = "foo" };
var target = new ExpressionObserver(data, "Foo");
target.Subscribe(_ => { });
Assert.Equal(typeof(string), target.ResultType);
}
public void Should_Get_Simple_Property_Chain_Type()
{
var data = new { Foo = new { Bar = new { Baz = "baz" } } };
var target = new ExpressionObserver(data, "Foo.Bar.Baz");
target.Subscribe(_ => { });
Assert.Equal(typeof(string), target.ResultType);
}
public void Should_Get_Simple_Property_Value_Type()
{
var data = new { Foo = "foo" };
var target = new ExpressionObserver(data, "Foo");
target.Subscribe(_ => { });
Assert.Equal(typeof(string), target.ResultType);
}
public void Disabled_Indei_Validation_Does_Not_Subscribe()
{
var data = new IndeiTest { MustBePositive = 5 };
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), false);
observer.Subscribe(_ => { });
Assert.Equal(0, data.SubscriptionCount);
}
public void SetValue_Should_Return_False_For_Missing_Object()
{
var data = new Class1();
var target = new ExpressionObserver(data, "Next.Bar");
using (target.Subscribe(_ => { }))
{
Assert.False(target.SetValue("baz"));
}
}
public void Enabled_Indei_Validation_Subscribes()
{
var data = new IndeiTest { MustBePositive = 5 };
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), true);
var sub = observer.Subscribe(_ => { });
Assert.Equal(1, data.ErrorsChangedSubscriptionCount);
sub.Dispose();
Assert.Equal(0, data.ErrorsChangedSubscriptionCount);
}
public void SetValue_Should_Notify_New_Value_Without_Inpc()
{
var data = new Class1();
var target = new ExpressionObserver(data, "Bar");
var result = new List <object>();
target.Subscribe(x => result.Add(x));
target.SetValue("bar");
Assert.Equal(new[] { null, "bar" }, result);
}
public void Should_Complete_When_Source_Observable_Errors()
{
var source = new BehaviorSubject<object>(1);
var target = new ExpressionObserver(source, "Foo");
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
source.OnError(new Exception());
Assert.True(completed);
}
public void Indei_Validation_Does_Not_Subscribe_When_DataValidatation_Not_Enabled()
{
var data = new IndeiTest {
MustBePositive = 5
};
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), false);
observer.Subscribe(_ => { });
Assert.Equal(0, data.ErrorsChangedSubscriptionCount);
}
public void Disabled_Indei_Validation_Does_Not_Subscribe()
{
var data = new IndeiTest {
MustBePositive = 5
};
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), false);
observer.Subscribe(_ => { });
Assert.Equal(0, data.SubscriptionCount);
}
public void Should_Complete_When_Update_Observable_Errors()
{
var update = new Subject<Unit>();
var target = new ExpressionObserver(() => 1, "Foo", update);
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
update.OnError(new Exception());
Assert.True(completed);
}
public void SetValue_Should_Return_False_For_Invalid_Value()
{
var data = new { Foo = "foo" };
var target = new ExpressionObserver(data, "!Foo");
target.Subscribe(_ => { });
Assert.False(target.SetValue("bar"));
GC.KeepAlive(data);
}
public void Should_Track_INCC_Add()
{
var data = new { Foo = new ObservableCollection<string> { "foo", "bar" } };
var target = new ExpressionObserver(data, "Foo[2]");
var result = new List<object>();
var sub = target.Subscribe(x => result.Add(x));
data.Foo.Add("baz");
Assert.Equal(new[] { PerspexProperty.UnsetValue, "baz" }, result);
}
public void Should_Complete_When_Update_Observable_Completes()
{
var update = new Subject <Unit>();
var target = new ExpressionObserver(() => 1, "Foo", update);
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
update.OnCompleted();
Assert.True(completed);
}
public void Should_Complete_When_Source_Observable_Completes()
{
var source = new BehaviorSubject <object>(1);
var target = new ExpressionObserver(source, "Foo");
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
source.OnCompleted();
Assert.True(completed);
}
public void Enabled_Indei_Validation_Subscribes()
{
var data = new IndeiTest {
MustBePositive = 5
};
var observer = new ExpressionObserver(data, nameof(data.MustBePositive), true);
var sub = observer.Subscribe(_ => { });
Assert.Equal(1, data.ErrorsChangedSubscriptionCount);
sub.Dispose();
Assert.Equal(0, data.ErrorsChangedSubscriptionCount);
}
public void Should_SetArrayIndex()
{
var data = new { Foo = new[] { "foo", "bar" } };
var target = new ExpressionObserver(data, "Foo[1]");
using (target.Subscribe(_ => { }))
{
Assert.True(target.SetValue("baz"));
}
Assert.Equal("baz", data.Foo[1]);
}
public void Should_Set_Value_On_Simple_Property_Chain()
{
var data = new Class1 { Foo = new Class2 { Bar = "bar" } };
var target = new ExpressionObserver(data, "Foo.Bar");
using (target.Subscribe(_ => { }))
{
target.SetValue("foo");
}
Assert.Equal("foo", data.Foo.Bar);
}
public void Should_Set_Simple_Property_Value()
{
var data = new { Foo = "foo" };
var target = new ExpressionObserver(data, "Foo");
using (target.Subscribe(_ => { }))
{
target.SetValue("bar");
}
Assert.Equal("foo", data.Foo);
}
public void Should_Set_Simple_Property_Value()
{
var data = new { Foo = "foo" };
var target = new ExpressionObserver(data, "Foo");
using (target.Subscribe(_ => { }))
{
target.SetValue("bar");
}
Assert.Equal("foo", data.Foo);
}
public void Subscribing_Multiple_Times_Should_Return_Values_To_All()
{
var data = new Class1 {
Foo = "foo"
};
var target = new ExpressionObserver(data, "Foo");
var result1 = new List <object>();
var result2 = new List <object>();
var result3 = new List <object>();
target.Subscribe(x => result1.Add(x));
target.Subscribe(x => result2.Add(x));
data.Foo = "bar";
target.Subscribe(x => result3.Add(x));
Assert.Equal(new[] { "foo", "bar" }, result1);
Assert.Equal(new[] { "foo", "bar" }, result2);
Assert.Equal(new[] { "bar" }, result3);
}
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 object Select(object o)
{
if (string.IsNullOrEmpty(MemberName))
{
return(o);
}
var expression = new ExpressionObserver(o, MemberName);
object result = AvaloniaProperty.UnsetValue;
expression.Subscribe(x => result = x);
return((result == AvaloniaProperty.UnsetValue || result is BindingNotification) ? null : result);
}
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 Should_Track_Simple_Property_Value()
{
var data = new Class1();
var target = new ExpressionObserver(data, "Foo");
var result = new List<object>();
var sub = target.Subscribe(x => result.Add(x));
data.SetValue(Class1.FooProperty, "bar");
Assert.Equal(new[] { "foo", "bar" }, result);
sub.Dispose();
}
public void Can_SetValue_For_Valid_Value()
{
var data = new Test {
Foo = true
};
var target = new ExpressionObserver(data, "!Foo");
target.Subscribe(_ => { });
Assert.True(target.SetValue(true));
Assert.False(data.Foo);
}
public object Select(object o)
{
if (string.IsNullOrEmpty(MemberName))
{
return o;
}
var expression = new ExpressionObserver(o, MemberName);
object result = AvaloniaProperty.UnsetValue;
expression.Subscribe(x => result = x);
return (result == AvaloniaProperty.UnsetValue || result is BindingNotification) ? null : result;
}
public void SetValue_Should_Return_False_For_Missing_Property()
{
var data = new Class1 {
Next = new WithoutBar()
};
var target = new ExpressionObserver(data, "Next.Bar");
using (target.Subscribe(_ => { }))
{
Assert.False(target.SetValue("baz"));
}
GC.KeepAlive(data);
}
public void Should_Track_Simple_Property_Value()
{
var data = new Class1();
var target = new ExpressionObserver(data, "Foo");
var result = new List <object>();
var sub = target.Subscribe(x => result.Add(x));
data.SetValue(Class1.FooProperty, "bar");
Assert.Equal(new[] { "foo", "bar" }, result);
sub.Dispose();
}
public void Should_Track_Simple_Attached_Value()
{
var data = new Class1();
var target = new ExpressionObserver(data, "(Owner.Foo)");
var result = new List<object>();
var sub = target.Subscribe(x => result.Add(x));
data.SetValue(Owner.FooProperty, "bar");
Assert.Equal(new[] { "foo", "bar" }, result);
sub.Dispose();
Assert.Null(((IAvaloniaObjectDebug)data).GetPropertyChangedSubscribers());
}
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_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_Not_Keep_Source_Alive_ObservableCollection_With_DataValidation()
{
Func<ExpressionObserver> run = () =>
{
var source = new { Foo = new AvaloniaList<string> { "foo", "bar" } };
var target = new ExpressionObserver(source, "Foo", true);
target.Subscribe(_ => { });
return target;
};
var result = run();
dotMemory.Check(memory =>
Assert.Equal(0, memory.GetObjects(where => where.Type.Is<AvaloniaList<string>>()).ObjectsCount));
}
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_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 object[] { AvaloniaProperty.UnsetValue, "foo" }, result.ToArray());
}
}
public void Should_Track_End_Of_Property_Chain_Changing()
{
var data = new Class1 { Next = new Class2 { Bar = "bar" } };
var target = new ExpressionObserver(data, "Next.Bar");
var result = new List<object>();
var sub = target.Subscribe(x => result.Add(x));
((Class2)data.Next).Bar = "baz";
Assert.Equal(new[] { "bar", "baz" }, result);
sub.Dispose();
Assert.Equal(0, data.SubscriptionCount);
Assert.Equal(0, data.Next.SubscriptionCount);
}
public void Should_Not_Keep_Source_Alive_NonIntegerIndexer()
{
Func<ExpressionObserver> run = () =>
{
var source = new { Foo = new NonIntegerIndexer() };
var target = new ExpressionObserver(source, "Foo");
target.Subscribe(_ => { });
return target;
};
var result = run();
dotMemory.Check(memory =>
Assert.Equal(0, memory.GetObjects(where => where.Type.Is<NonIntegerIndexer>()).ObjectsCount));
}
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]);
}
}
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_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_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_Return_BindingNotification_Error_On_Task_Exception()
{
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.SetException(new NotSupportedException());
sync.ExecutePostedCallbacks();
Assert.Equal(
new[]
{
new BindingNotification(
new AggregateException(new NotSupportedException()),
BindingErrorType.Error)
},
result);
}
}
public void Can_Replace_Root()
{
var first = new Class1 { Foo = "foo" };
var second = new Class1 { Foo = "bar" };
var root = first;
var update = new Subject<Unit>();
var target = new ExpressionObserver(() => root, "Foo", update);
var result = new List<object>();
var sub = target.Subscribe(x => result.Add(x));
root = second;
update.OnNext(Unit.Default);
root = null;
update.OnNext(Unit.Default);
Assert.Equal(new[] { "foo", "bar", PerspexProperty.UnsetValue }, result);
Assert.Equal(0, first.SubscriptionCount);
Assert.Equal(0, second.SubscriptionCount);
}