public void ClearValueDoesNotTriggersINPCOnSameValues() { var bindable = new MockBindable(); bool changingfired = false; bool changedfired = false; bool changingdelegatefired = false; bool changeddelegatefired = false; var property = BindableProperty.Create("Foo", typeof(string), typeof(MockBindable), "foo", propertyChanged: (b, o, n) => changeddelegatefired = true, propertyChanging: (b, o, n) => changingdelegatefired = true ); bindable.PropertyChanged += (sender, e) => { changedfired |= e.PropertyName == "Foo"; }; bindable.PropertyChanging += (sender, e) => { changingfired |= e.PropertyName == "Foo"; }; bindable.SetValue(property, "foobar"); bindable.SetValue(property, "foo"); changingfired = changedfired = changeddelegatefired = changingdelegatefired = false; bindable.ClearValue(property); Assert.False(changingfired); Assert.False(changedfired); Assert.False(changingdelegatefired); Assert.False(changeddelegatefired); }
public void SetBindingInvalid() { var mock = new MockBindable(); Assert.Throws <ArgumentNullException> (() => mock.SetBinding(null, new Binding("."))); Assert.Throws <ArgumentNullException> (() => mock.SetBinding(MockBindable.TextProperty, null)); }
void TestGetValueDefault(BindableProperty property) { var mock = new MockBindable(); object value = mock.GetValue(property); Assert.AreEqual(property.DefaultValue, value); }
public void RaiseOnEqual() { string foo = "foo"; var mock = new MockBindable(); mock.SetValue(MockBindable.TextProperty, foo); bool changing = false; mock.PropertyChanging += (o, e) => { Assert.That(e.PropertyName, Is.EqualTo(MockBindable.TextProperty.PropertyName)); changing = true; }; bool changed = true; mock.PropertyChanged += (o, e) => { Assert.That(e.PropertyName, Is.EqualTo(MockBindable.TextProperty.PropertyName)); changed = true; }; mock.SetValueCore(MockBindable.TextProperty, foo, BindableObject.SetValueFlags.ClearOneWayBindings | BindableObject.SetValueFlags.ClearDynamicResource | BindableObject.SetValueFlags.RaiseOnEqual); Assert.That(changing, Is.True, "PropertyChanging event did not fire"); Assert.That(changed, Is.True, "PropertyChanged event did not fire"); }
public void DefaultValueCreatorDoesNotTriggerINPC() { int invoked = 0; int propertychanged = 0; int changedfired = 0; var bindableProperty = BindableProperty.Create("Foo", typeof(object), typeof(MockBindable), null, propertyChanged: (bindable, oldvalue, newvalue) => { propertychanged++; }, defaultValueCreator: o => { invoked++; return(new object()); }); var bp = new MockBindable(); bp.PropertyChanged += (sender, e) => { if (e.PropertyName == "Foo") { changedfired++; } }; var value0 = bp.GetValue(bindableProperty); Assert.NotNull(value0); Assert.AreEqual(1, invoked); Assert.AreEqual(0, propertychanged); Assert.AreEqual(0, changedfired); }
public void ValueUpdatedWithOldContextDoesNotUpdateWithOneWayToSourceBinding(bool isDefault) { const string newvalue = "New Value"; var viewmodel = new MockViewModel { Text = "Foo" }; BindingMode propertyDefault = BindingMode.OneWay; BindingMode bindingMode = BindingMode.OneWayToSource; if (isDefault) { propertyDefault = BindingMode.OneWayToSource; bindingMode = BindingMode.Default; } var property = BindableProperty.Create("Text", typeof(string), typeof(MockBindable), "default value", propertyDefault); var binding = CreateBinding(bindingMode); var bindable = new MockBindable(); bindable.BindingContext = viewmodel; bindable.SetBinding(property, binding); bindable.BindingContext = new MockViewModel(); Assert.AreEqual(property.DefaultValue, bindable.GetValue(property)); viewmodel.Text = newvalue; Assert.AreEqual(property.DefaultValue, bindable.GetValue(property), "Target updated from old Source property change"); Assert.That(log.Messages.Count, Is.EqualTo(0), "An error was logged: " + log.Messages.FirstOrDefault()); }
public void ValueUpdatedWithSimplePathOnOneWayBinding( [Values(true, false)] bool isDefault) { const string newvalue = "New Value"; var viewmodel = new MockViewModel { Text = "Foo" }; BindingMode propertyDefault = BindingMode.OneWay; BindingMode bindingMode = BindingMode.OneWay; if (isDefault) { propertyDefault = BindingMode.OneWay; bindingMode = BindingMode.Default; } var property = BindableProperty.Create("Text", typeof(string), typeof(MockBindable), "default value", propertyDefault); var binding = CreateBinding(bindingMode); var bindable = new MockBindable(); bindable.BindingContext = viewmodel; bindable.SetBinding(property, binding); viewmodel.Text = newvalue; Assert.AreEqual(newvalue, bindable.GetValue(property), "Bindable did not update on binding context property change"); Assert.AreEqual(newvalue, viewmodel.Text, "Source property changed when it shouldn't"); Assert.That(log.Messages.Count, Is.EqualTo(0), "An error was logged: " + log.Messages.FirstOrDefault()); }
public void DefaultValueCreatorCalledForChangeDelegates() { int changedOld = -1; int changedNew = -1; int changingOld = -1; int changingNew = -1; var prop = BindableProperty.Create("Foo", typeof(int), typeof(MockBindable), 0, defaultValueCreator: b => 10, propertyChanged: (b, value, newValue) => { changedOld = (int)value; changedNew = (int)newValue; }, propertyChanging: (b, value, newValue) => { changingOld = (int)value; changingNew = (int)newValue; }); var bindable = new MockBindable(); var defaultValue = (int)bindable.GetValue(prop); Assert.AreEqual(10, defaultValue); bindable.SetValue(prop, 5); bindable.ClearValue(prop); Assert.AreEqual(5, changedOld); Assert.AreEqual(5, changingOld); Assert.AreEqual(10, changedNew); Assert.AreEqual(10, changingNew); }
public void BindingStaysOnUpdateValueFromBinding() { const string newvalue = "New Value"; var viewmodel = new MockViewModel { Text = "Foo" }; var property = BindableProperty.Create("Text", typeof(string), typeof(MockBindable), null); var binding = CreateBinding(BindingMode.Default); var bindable = new MockBindable(); bindable.BindingContext = viewmodel; bindable.SetBinding(property, binding); viewmodel.Text = newvalue; Assert.AreEqual(newvalue, bindable.GetValue(property)); const string newValue2 = "new value 2"; viewmodel.Text = newValue2; Assert.AreEqual(newValue2, bindable.GetValue(property)); Assert.That(log.Messages.Count, Is.EqualTo(0), "An error was logged: " + log.Messages.FirstOrDefault()); }
public void GetSetValue() { const string value = "foo"; var mock = new MockBindable(); mock.SetValue(MockBindable.TextProperty, value); Assert.AreEqual(value, mock.GetValue(MockBindable.TextProperty)); }
public void ValidateValue() { var property = BindableProperty.Create <MockBindable, string> (w => w.Foo, null, validateValue: (b, v) => false); var mock = new MockBindable(); Assert.Throws <ArgumentException> (() => mock.SetValue(property, null)); }
//https://bugzilla.xamarin.com/show_bug.cgi?id=27299 public void BindingOnBindingContextDoesntReapplyBindingContextBinding() { var bindable = new MockBindable(); var locator = new VMLocator(); Assert.AreEqual(0, locator.Count); locator.Invoked += (sender, e) => Assert.IsTrue(locator.Count <= 1); bindable.SetBinding(BindableObject.BindingContextProperty, new Binding("VM", source: locator)); Assert.IsTrue(locator.Count == 1); }
//https://bugzilla.xamarin.com/show_bug.cgi?id=24485 public void BindingContextBoundThroughConverter() { var bindable = new MockBindable(); bindable.BindingContext = "test"; bindable.SetBinding(BindableObject.BindingContextProperty, new Binding(".", converter: new BindingContextConverter())); bindable.SetBinding(MockBindable.TextProperty, "Text"); Assert.That(() => bindable.Text, Is.EqualTo("testConverted")); }
public void SetValueCoreInvokesOpImplicitOnValue() { var prop = BindableProperty.Create("Foo", typeof(string), typeof(MockBindable), null); var bindable = new MockBindable(); Assert.Null(bindable.GetValue(prop)); bindable.SetValue(prop, new CastToString("foo")); Assert.AreEqual("foo", bindable.GetValue(prop)); }
public void SetValueCoreInvokesOpImplicitOnPropertyType() { var prop = BindableProperty.Create("Foo", typeof(CastFromString), typeof(MockBindable), null); var bindable = new MockBindable(); Assert.Null(bindable.GetValue(prop)); bindable.SetValue(prop, "foo"); Assert.AreEqual("foo", ((CastFromString)bindable.GetValue(prop)).Result); }
public void BindingContextChangedEvent() { var mock = new MockBindable(); mock.BindingContextChanged += (sender, args) => Assert.Pass(); mock.BindingContext = new object(); Assert.Fail("The BindingContextChanged event was not fired."); }
public void CoerceValue() { var property = BindableProperty.Create <MockBindable, string> (w => w.Foo, null, coerceValue: (bo, o) => o.ToUpper()); const string value = "value"; var mock = new MockBindable(); mock.SetValue(property, value); Assert.AreEqual(value.ToUpper(), mock.GetValue(property)); }
public void PropertyChangingDefaultValue() { var prop = BindableProperty.Create <MockBindable, string> (w => w.Foo, "DefaultValue"); var mock = new MockBindable(); mock.PropertyChanging += (s, e) => Assert.Fail(); mock.SetValue(prop, prop.DefaultValue); Assert.Pass(); }
public void BindingContext() { var mock = new MockBindable(); Assert.IsNull(mock.BindingContext); object obj = new object(); mock.BindingContext = obj; Assert.AreSame(obj, mock.BindingContext); }
public void CreateContentValues() { var template = new DataTemplate(typeof(MockBindable)) { Values = { { MockBindable.TextProperty, "value" } } }; MockBindable bindable = (MockBindable)template.CreateContent(); Assert.That(bindable.GetValue(MockBindable.TextProperty), Is.EqualTo("value")); }
public void ClearValue() { const string value = "foo"; var mock = new MockBindable(); mock.SetValue(MockBindable.TextProperty, value); Assert.AreEqual(value, mock.GetValue(MockBindable.TextProperty)); mock.ClearValue(MockBindable.TextProperty); TestGetValueDefault(MockBindable.TextProperty); }
public void SetValueCoreImplicitelyCastBasicType() { var prop = BindableProperty.Create("Foo", typeof(int), typeof(MockBindable), 0); var bindable = new MockBindable(); Assert.DoesNotThrow(() => bindable.SetValue(prop, (object)(short)42)); Assert.AreEqual(42, bindable.GetValue(prop)); bindable.SetValue(prop, (object)(long)-42); Assert.AreNotEqual(-42, bindable.GetValue(prop)); }
public void CreateContentBindings() { var template = new DataTemplate(() => new MockBindable()) { Bindings = { { MockBindable.TextProperty, new Binding(".") } } }; MockBindable bindable = (MockBindable)template.CreateContent(); bindable.BindingContext = "text"; Assert.That(bindable.GetValue(MockBindable.TextProperty), Is.EqualTo("text")); }
public void OneWayToSourceContextSetToNull() { var binding = new Binding("Text", BindingMode.OneWayToSource); MockBindable bindable = new MockBindable { BindingContext = new MockViewModel() }; bindable.SetBinding(MockBindable.TextProperty, binding); Assert.That(() => bindable.BindingContext = null, Throws.Nothing); }
public void SetValueOverridesBinding() { var template = new DataTemplate(typeof(MockBindable)); template.SetBinding(MockBindable.TextProperty, new Binding(".")); template.SetValue(MockBindable.TextProperty, "value"); MockBindable bindable = (MockBindable)template.CreateContent(); Assert.That(bindable.GetValue(MockBindable.TextProperty), Is.EqualTo("value")); bindable.BindingContext = "binding"; Assert.That(bindable.GetValue(MockBindable.TextProperty), Is.EqualTo("value")); }
public void PropertyChangedSameValue() { const string value = "foo"; var mock = new MockBindable(); mock.SetValue(MockBindable.TextProperty, value); mock.PropertyChanged += (s, e) => Assert.Fail(); mock.SetValue(MockBindable.TextProperty, value); Assert.Pass(); }
public void TestBindingTwoWayOnReadOnly() { var bindablePropertyKey = BindableProperty.CreateReadOnly <MockBindable, string> (w => w.Foo, "DefaultValue", BindingMode.OneWayToSource); var bindableProperty = bindablePropertyKey.BindableProperty; var bindable = new MockBindable(); var vm = new MockViewModel(); bindable.SetBinding(bindableProperty, new Binding("Text", BindingMode.TwoWay)); Assert.DoesNotThrow(() => bindable.BindingContext = vm); Assert.AreEqual("DefaultValue", bindable.GetValue(bindableProperty)); }
public void PropertyChanging() { var mock = new MockBindable(); mock.PropertyChanging += (sender, args) => { Assert.AreEqual(MockBindable.TextProperty.PropertyName, args.PropertyName); Assert.AreEqual(MockBindable.TextProperty.DefaultValue, mock.GetValue(MockBindable.TextProperty)); Assert.Pass(); }; mock.SetValue(MockBindable.TextProperty, "foo"); Assert.Fail("The PropertyChanging event was not fired."); }
public void TestBehaviorsAttachedDP() { var behavior = new MockBehavior <MockBindable> (); var bindable = new MockBindable(); var collection = bindable.Behaviors; Assert.Null(behavior.AssociatedObject); collection.Add(behavior); Assert.AreSame(bindable, behavior.AssociatedObject); collection.Remove(behavior); Assert.Null(behavior.AssociatedObject); }
public void RecursiveChange() { bool changedA1 = false, changedA2 = false, changedB1 = false, changedB2 = false; var mock = new MockBindable(); mock.PropertyChanged += (sender, args) => { if (!changedA1) { Assert.AreEqual("1", mock.GetValue(MockBindable.TextProperty)); Assert.IsFalse(changedA2); Assert.IsFalse(changedB1); Assert.IsFalse(changedB2); mock.SetValue(MockBindable.TextProperty, "2"); changedA1 = true; } else { Assert.AreEqual("2", mock.GetValue(MockBindable.TextProperty)); Assert.IsFalse(changedA2); Assert.IsTrue(changedB1); Assert.IsFalse(changedB2); changedA2 = true; } }; mock.PropertyChanged += (sender, args) => { if (!changedB1) { Assert.AreEqual("1", mock.GetValue(MockBindable.TextProperty)); Assert.IsTrue(changedA1); Assert.IsFalse(changedA2); Assert.IsFalse(changedB2); changedB1 = true; } else { Assert.AreEqual("2", mock.GetValue(MockBindable.TextProperty)); Assert.IsTrue(changedA1); Assert.IsTrue(changedA2); Assert.IsFalse(changedB2); changedB2 = true; } }; mock.SetValue(MockBindable.TextProperty, "1"); Assert.AreEqual("2", mock.GetValue(MockBindable.TextProperty)); Assert.IsTrue(changedA1); Assert.IsTrue(changedA2); Assert.IsTrue(changedB1); Assert.IsTrue(changedB2); }