public void TestCircularSubscriptions() { int timesNotified1 = 0; int timesNotified2 = 0; var property1 = new ObservableProperty<string>("initVal1"); var property2 = new ObservableProperty<string>("initVal2"); property1.Subscribe(value => { timesNotified1++; property2.Value = value; }, property2); property2.Subscribe(value => { timesNotified2++; property1.Value = value; }, property1); Assert.AreEqual(0, timesNotified1); Assert.AreEqual(0, timesNotified2); Assert.AreEqual("initVal1", property1.Value); Assert.AreEqual("initVal2", property2.Value); property1.Value = "don't loop!"; Assert.AreEqual("don't loop!", property1.Value); Assert.AreEqual("don't loop!", property2.Value); Assert.AreEqual(1, timesNotified1); Assert.AreEqual(0, timesNotified2); }
public void TestDontDependWithPeek() { var property = new ObservableProperty<int>(5); var computed = new ComputedObservable<int>(() => property.Peek() + 1); Assert.AreEqual(6, computed.Value); property.Value = 10; Assert.AreEqual(6, computed.Value); }
public void TestCustomEventIgnoreDefaultNotify() { var property = new ObservableProperty<string>("initVal"); string notifiedValue = null; var subscription = property.Subscribe(value => notifiedValue = value, "test", "myEvent"); property.NotifySubscribers("ignore"); Assert.IsNull(notifiedValue); }
public void TestNotifyDefaultValueChange() { var property = new ObservableProperty<string>(); string notifiedValue = null; property.Subscribe(value => notifiedValue = value, "test"); property.Value = "test"; Assert.AreEqual("test", notifiedValue); }
public void TestNotifySubscribers() { var property = new ObservableProperty<string>(); string notifiedValue = null; property.Subscribe(value => notifiedValue = value, "test"); property.NotifySubscribers("test"); Assert.AreEqual("test", notifiedValue); }
public void TestNotifyCustomEvent() { var property = new ObservableProperty<string>("initVal"); string notifiedValue = null; var subscription = property.SubscribeEvent<string>(value => notifiedValue = value, "myEvent", "test"); property.OnNotifySubscribers("bla", "undefinedEvent"); Assert.IsNull(notifiedValue); property.OnNotifySubscribers("expected", "myEvent"); Assert.AreEqual("expected", notifiedValue); }
public SelectedListViewModel() { Friends = Observe.List(new Friend("jo"), new Friend("Jason"), new Friend("Rachael"), new Friend("Nathan"), new Friend("Bob")); SelectedFriend = new ObservableProperty<Friend>(); SelectedFriendName = new ComputedObservable<string>( () => SelectedFriend.Value == null ? string.Empty : SelectedFriend.Value.Name.Value, value => SelectedFriend.Value.Name.Value = value); }
public void View(ObservableProperty<Guest> selectedGuest) { if (_guest != null) throw new InvalidOperationException("guest already setup"); _guest = selectedGuest; _name = Observe.TwoWayComputed(() => _guest.Value.Name); _attending = Observe.TwoWayComputed(() => _guest.Value.Attending); _invited = Observe.TwoWayComputed(() => _guest.Value.InvitedDate); _foodChoice = Observe.TwoWayComputed(() => _guest.Value.FoodChoice); _name.BindText(nameTextBox); _attending.BindCheckBox(attendingCheckBox); _invited.BindDate(invitedDateCalendar); _foodChoice.BindSelectedComboBox(foodTypeComboBox); }
public void TestEvaluateAfterDisposed() { int timesEvaluated = 0; var underlyingProperty = new ObservableProperty<int>(1); var computed = new ComputedObservable<int>(() => { timesEvaluated++; return underlyingProperty.Value; }); Assert.AreEqual(1, timesEvaluated); computed.Dispose(); underlyingProperty.Value = 2; Assert.AreEqual(1, timesEvaluated); Assert.AreEqual(1, computed.Value); Assert.AreEqual(0, computed.DependencyCount); }
public void TestComplexTwoWayBinding() { var kevin = new TestModel("Kevin") ; var jacob = new TestModel("Jacob") {TestEnumValue = { Value = TestEnum.three}}; var observableObject = new ObservableProperty<TestModel>(kevin); var testEnumObserver = Observe.TwoWayComputed(() => observableObject.Value.TestEnumValue); Assert.AreEqual(TestEnum.one, testEnumObserver.Value); testEnumObserver.Value = TestEnum.two; Assert.AreEqual(TestEnum.two, kevin.TestEnumValue.Value); observableObject.Value = jacob; Assert.AreEqual(TestEnum.three, testEnumObserver.Value); testEnumObserver.Value = TestEnum.one; observableObject.Value = kevin; Assert.AreEqual(TestEnum.two, testEnumObserver.Value); }
public void TestComputeSubscriptionOnListOfObservables() { int timesComputed = 0; var list = ObservableList.New(5, 6, 7); list.Name = "List"; var computed = new ComputedObservable<int>(() => { timesComputed++; return list[2].Value + 1; }) {Name = "ComputedVal"}; Assert.AreEqual(8, computed.Value); Assert.AreEqual(1, timesComputed); list[0].Value = 1; Assert.AreEqual(1, timesComputed); list[2].Value = 3; Assert.AreEqual(4, computed.Value); Assert.AreEqual(2, timesComputed); list[1] = new ObservableProperty<int>(10); Assert.AreEqual(2, timesComputed); list[2] = new ObservableProperty<int>(10); Assert.AreEqual(3, timesComputed); Assert.AreEqual(11, computed.Value); }
public void TestLongChains() { try { int depth = 1000; var first = new ObservableProperty<int>(0); var last = first; for (int i = 0; i < depth; i++) { var previous = last; last = new ComputedObservable<int>(() => previous.Value + 1); } var all = new ComputedObservable<int>(() => first.Value + last.Value); first.Value = 1; Assert.AreEqual(depth + 2, all.Value); } catch (StackOverflowException) { Assert.Fail("Stack overflow"); } }
public void TestNotifyBeforeChange() { string notifiedValue = null; var property = new ObservableProperty<string>("test"); var computed = new ComputedObservable<string>(() => property + "_computed"); computed.Subscribe(value => notifiedValue = value, ObservableProperty.BEFORE_VALUE_CHANGED_EVENT, "test"); Assert.IsNull(notifiedValue); property.Value = "is"; Assert.AreEqual("test_computed", notifiedValue); Assert.AreEqual("is_computed", computed.Value); }
public void TestNotAddingDependencyWhenDisposedDuringEvaluation() { int timesEvaluated = 0; var underlyingProperty = new ObservableProperty<int>(1); var propertyToTrigerDipose = new ObservableProperty<bool>(false); ComputedObservable<int> computed = null; computed = new ComputedObservable<int>(() => { if (propertyToTrigerDipose.Value) { computed.Dispose(); } timesEvaluated++; return underlyingProperty.Value; }); Assert.AreEqual(1, timesEvaluated); Assert.AreEqual(1, computed.Value); Assert.AreEqual(2, computed.DependencyCount); Assert.AreEqual(1, underlyingProperty.SubscriptionsCount); propertyToTrigerDipose.Value = true; Assert.AreEqual(2, timesEvaluated); Assert.AreEqual(1, computed.Value); Assert.AreEqual(0, computed.DependencyCount); Assert.AreEqual(0, underlyingProperty.SubscriptionsCount); }
public void TestObservableChain() { var underlyingProperty = new ObservableProperty<int>(1); var computed1 = new ComputedObservable<int>(() => 1 + underlyingProperty); var computed2 = new ComputedObservable<int>(() => 1 + computed1); Assert.AreEqual(3, computed2.Value); underlyingProperty.Value = 11; Assert.AreEqual(13, computed2.Value); }
public void TestNotifySubscribers() { string notifiedValue = null; var property = new ObservableProperty<string>("test"); var computed = new ComputedObservable<string>(() => property + "_computed"); computed.Subscribe(value => notifiedValue = value, "test"); Assert.IsNull(notifiedValue); property.Value = "is"; Assert.AreEqual("is_computed", computed.Value); }
public void TestSubscribeInvokesEvalOnDefer() { var underlyingProperty = new ObservableProperty<int>(1); var computed = new ComputedObservable<int>(() => underlyingProperty.Value, true); var result = new ObservableProperty<int>(); Assert.AreEqual(0, computed.DependencyCount); computed.Subscribe(value => result.Value = value, "test"); Assert.AreEqual(1, computed.DependencyCount); Assert.AreEqual(0, result.Value); underlyingProperty.Value = 42; Assert.AreEqual(42, result.Value); }
public void TestUnsubscribeCustomEvent() { var property = new ObservableProperty<string>("initVal"); string notifiedValue = null; var subscription = property.Subscribe(value => notifiedValue = value, "test", "myEvent"); subscription.Dispose(); property.OnNotifySubscribers("ignore", "myEvent"); Assert.IsNull(notifiedValue); }
public void TestPreventRecursionOnSetDependency() { int timesEvaluated = 0; var underlyingProperty = new ObservableProperty<int>(1); var computed = new ComputedObservable<int>(() => { timesEvaluated++; underlyingProperty.Value = (underlyingProperty.Value + 1); return 1; }); Assert.AreEqual(1, timesEvaluated); }
public void TestPeekComputed() { var underlyingProperty = new ObservableProperty<int>(1); var computed1 = new ComputedObservable<int>(() => 1 + underlyingProperty); var computed2 = new ComputedObservable<int>(() => 1 + computed1.Peek()); Assert.AreEqual(3, computed2.Value); Assert.AreEqual(0, computed2.DependencyCount); underlyingProperty.Value = 11; Assert.AreEqual(3, computed2.Value); }
public void TestUnsubscribeOnEachChange() { var propertyA = new ObservableProperty<string>("A"); var propertyB = new ObservableProperty<string>("B"); string propertyToUse = "A"; int timesEvaluated = 0; var computed = new ComputedObservable<string>(() => { timesEvaluated++; return propertyToUse == "A" ? propertyA.Value : propertyB.Value; }); Assert.AreEqual("A", computed.Value); Assert.AreEqual(1, timesEvaluated); // Changing an unrelated observable doesn't trigger evaluation propertyB.Value = "B2"; Assert.AreEqual(1, timesEvaluated); // Switch to other observable propertyToUse = "B"; propertyA.Value = "A2"; Assert.AreEqual("B2", computed.Value); Assert.AreEqual(2, timesEvaluated); // Now changing the first observable doesn't trigger evaluation Assert.AreEqual(2, timesEvaluated); propertyA.Value = "A3"; }
public void TestUpdateWhenDependencyChanges() { var property = new ObservableProperty<int>(5); var computed = new ComputedObservable<int>(() => property.Value + 1); Assert.AreEqual(6, computed.Value); property.Value = 10; Assert.AreEqual(11, computed.Value); }
public void TestTwoWayComputed() { var testEnumProperty = new ObservableProperty<TestEnum>(); var computed = Observe.TwoWayComputed(() => testEnumProperty); TestEnum lastNotifyValue = TestEnum.two; computed.Subscribe(value => lastNotifyValue = value, "test"); Assert.AreEqual(TestEnum.one, computed.Value); testEnumProperty.Value = TestEnum.two; Assert.AreEqual(TestEnum.two, computed.Value); Assert.AreEqual(TestEnum.two, lastNotifyValue); testEnumProperty.Value = TestEnum.one; Assert.AreEqual(TestEnum.one, computed.Value); Assert.AreEqual(TestEnum.one, lastNotifyValue); }
public void TestPreventSubscribeViewChangeNotification() { var underlyingProperty = new ObservableProperty<int>(1); var independentProperty = new ObservableProperty<int>(1); var computed = new ComputedObservable<int>(() => underlyingProperty.Value); Assert.AreEqual(1, computed.DependencyCount); computed.Subscribe(value => { var tmp = independentProperty.Value; }, "test"); underlyingProperty.Value = 2; Assert.AreEqual(1, computed.DependencyCount); computed.Subscribe(value => { var tmp = independentProperty.Value; }, ObservableProperty.BEFORE_VALUE_CHANGED_EVENT, "test"); underlyingProperty.Value = 3; Assert.AreEqual(1, computed.DependencyCount); }
public void TestSingleUpdateOnChain() { int timesEvaluated = 0; var underlyingPropertyLeft = new ObservableProperty<int>(1) {Name = "Left"}; var underlyingPropertyRight = new ObservableProperty<int>(1) {Name = "Right"}; var computed1 = new ComputedObservable<int>(() => underlyingPropertyRight + underlyingPropertyLeft) { Name = "Compute1" }; var computed2 = new ComputedObservable<int>(() => { timesEvaluated++; return underlyingPropertyLeft + computed1 + underlyingPropertyRight; }) { Name = "Compute2" }; Assert.AreEqual(1, timesEvaluated); Assert.AreEqual(4, computed2); underlyingPropertyLeft.Value = 2; Assert.AreEqual(6, computed2); Assert.AreEqual(2, timesEvaluated); underlyingPropertyRight.Value = 2; Assert.AreEqual(8, computed2); Assert.AreEqual(3, timesEvaluated); }
public void TestPreventNotifyAfterUnsubscribe() { var property = new ObservableProperty<string>(); ObservableSubscription<string> subscription1 = null; ObservableSubscription<string> subscription2 = null; subscription1 = property.Subscribe(value => subscription2.Dispose(), "test"); bool subscription2WasNotified = false; subscription2 = property.Subscribe(value => subscription2WasNotified = true, "test"); property.NotifySubscribers("ignore"); Assert.AreEqual(false, subscription2WasNotified); }
public void TestUnsubscribe() { var property = new ObservableProperty<string>("initVal"); string notifiedValue = null; var subscription = property.Subscribe(value => notifiedValue = value, "test"); subscription.Dispose(); property.NotifySubscribers("test"); Assert.AreEqual(null, notifiedValue); }
public void TestSubscriptionCounts() { var underlyingPropertyLeft = new ObservableProperty<int>(1) {Name = "Left"}; var underlyingPropertyRight = new ObservableProperty<int>(1) {Name = "Right"}; var simpleComputed = new ComputedObservable<int>(() => underlyingPropertyLeft + 5, true); var layerdComputed = new ComputedObservable<int>(() => simpleComputed + underlyingPropertyRight); Assert.AreEqual(simpleComputed.DependencyCount, 1); Assert.AreEqual(layerdComputed.DependencyCount, 2); }
public void TestSingleUpdateOnMultipleCalls() { var property = new ObservableProperty<int>(2); var computed = new ComputedObservable<int>(() => property + property); Assert.AreEqual(1, computed.DependencyCount); List<int> notifiedValues = new List<int>(); computed.Subscribe(value => notifiedValues.Add(value), "test"); Assert.AreEqual(4, computed.Value); property.Value = 4; Assert.AreEqual(1, notifiedValues.Count); Assert.AreEqual(8, notifiedValues[0]); }