public void ShouldUpdateSelectedItemInSelectorWhenPropertyChanges()
{
var model = new MockModel();
var item1 = new MockItem {
Property = 1
};
var item2 = new MockItem {
Property = 2
};
var itemsSource = new List <MockItem> {
item1, item2
};
var selector = new ComboBox();
selector.ItemsSource = itemsSource;
SelectorExtensions.SetSelectedValuePath(selector, "Property");
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
Assert.AreNotSame(item2, selector.SelectedItem);
model.SelectedValueInModel = 2;
Assert.AreSame(item2, selector.SelectedItem);
}
public void BindableComponentTest()
{
Control c = new Control();
MockItem item = new MockItem(String.Empty, 0);
Binding binding = new Binding("Text", item, "Text");
c.DataBindings.Add(binding);
Assert.AreEqual(c, binding.Control, "#A1");
Assert.AreEqual(c, binding.BindableComponent, "#A2");
//
// Now use IBindableComponent - update binding when property changes
// since ToolStripItem doesn't have validation at all
//
BindableToolStripItem toolstrip_item = new BindableToolStripItem();
toolstrip_item.BindingContext = new BindingContext();
Binding binding2 = new Binding("Text", item, "Text");
binding2.DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged;
item.Text = "A";
toolstrip_item.DataBindings.Add(binding2);
Assert.AreEqual(null, binding2.Control, "#B1");
Assert.AreEqual(toolstrip_item, binding2.BindableComponent, "#B2");
Assert.AreEqual(item.Text, toolstrip_item.Text, "#B3");
toolstrip_item.Text = "B";
Assert.AreEqual(toolstrip_item.Text, item.Text, "#C1");
}
public void DataSourceUpdateModeTest()
{
Control c = new Control();
c.BindingContext = new BindingContext();
c.CreateControl();
MockItem item = new MockItem("A", 0);
Binding binding = new Binding("Text", item, "Text");
binding.DataSourceUpdateMode = DataSourceUpdateMode.Never;
c.DataBindings.Add(binding);
Assert.AreEqual("A", c.Text, "#A1");
c.Text = "B";
Assert.AreEqual("A", item.Text, "#B1");
binding.DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged;
Assert.AreEqual("A", item.Text, "#C1");
c.Text = "C";
Assert.AreEqual("C", item.Text, "#D1");
// This requires a Validation even, which we can't test
// by directly modifying the property
binding.DataSourceUpdateMode = DataSourceUpdateMode.OnValidation;
c.Text = "D";
Assert.AreEqual("C", item.Text, "#E1");
}
public void ShouldUpdateModelOnSelectionChange()
{
var model = new MockModel();
var item1 = new MockItem {
Property = 1
};
var item2 = new MockItem {
Property = 2
};
var itemsSource = new List <MockItem> {
item1, item2
};
var selector = new ComboBox();
selector.ItemsSource = itemsSource;
SelectorExtensions.SetSelectedValuePath(selector, "Property");
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
selector.SelectedItem = item1;
Assert.AreEqual(item1.Property, model.SelectedValueInModel);
selector.SelectedItem = item2;
Assert.AreEqual(item2.Property, model.SelectedValueInModel);
}
/*--------------------------------------------------------------------------------------------*/
protected override void CheckSuccess(bool pSuccess)
{
Times t = (pSuccess ? Times.Once() : Times.Never());
MockItem.Verify(x => x.VerifyParamCount(1, -1), Times.Once);
MockPath.Verify(x => x.AddScript(vScript), t);
}
public void IsBindingSuspendedTest()
{
Control c = new Control();
c.BindingContext = new BindingContext();
MockItem item = new MockItem("A", 0);
MockItem [] items = new MockItem [] { item };
BindingManagerBase manager = c.BindingContext [item];
BindingManagerBase manager2 = c.BindingContext [items];
Assert.IsFalse(manager.IsBindingSuspended, "#A1");
Assert.IsFalse(manager2.IsBindingSuspended, "#A2");
manager.SuspendBinding();
manager2.SuspendBinding();
Assert.IsFalse(manager.IsBindingSuspended, "#B1");
Assert.IsTrue(manager2.IsBindingSuspended, "#B2");
manager.ResumeBinding();
manager2.ResumeBinding();
Assert.IsFalse(manager.IsBindingSuspended, "#C1");
Assert.IsFalse(manager2.IsBindingSuspended, "#C2");
}
public override void SetUp()
{
base.SetUp();
vPropDbName = DbName.Vert.Factor.EventorDateTime;
vOperation = "lte";
vYear = 2000;
vMonth = 1;
vDay = 17;
vHour = 13;
vMinute = 52;
vSecond = 3;
vValue = DataUtil.EventorTimesToLong(vYear, vMonth, vDay, vHour, vMinute, vSecond);
vPropDbNameParam = "_P0";
vValueParam = "_P1";
vScript = ".has(" + vPropDbNameParam + ", Tokens.T.lte, " + vValueParam + ")";
vToType = typeof(FabArtifact);
vStep = new TravStepWhereEventorDateTime();
MockItem.Setup(x => x.VerifyParamCount(7, -1));
MockItem.Setup(x => x.GetParamAt <string>(0)).Returns(vOperation);
MockItem.Setup(x => x.GetParamAt <long>(1)).Returns(vYear);
MockItem.Setup(x => x.GetParamAt <byte>(2)).Returns(vMonth);
MockItem.Setup(x => x.GetParamAt <byte>(3)).Returns(vDay);
MockItem.Setup(x => x.GetParamAt <byte>(4)).Returns(vHour);
MockItem.Setup(x => x.GetParamAt <byte>(5)).Returns(vMinute);
MockItem.Setup(x => x.GetParamAt <byte>(6)).Returns(vSecond);
MockPath.Setup(x => x.AddParam(vPropDbName)).Returns(vPropDbNameParam);
MockPath.Setup(x => x.AddParam(vValue)).Returns(vValueParam);
MockPath.Setup(x => x.AddScript(vScript));
}
public void DataSourcePropertyChanged_ThreeDeep()
{
Control c = new Control();
c.BindingContext = new BindingContext();
c.CreateControl();
MockItem item = new MockItem("A", 0);
One parent = new One();
parent.Two = new Two();
parent.Two.Three = new Three();
parent.Two.Three.MockItem = item;
Binding binding = new Binding("Text", parent, "Two.Three.MockItem.Text");
c.DataBindings.Add(binding);
Console.WriteLine("c.Text: " + c.Text);
Assert.AreEqual("A", c.Text, "#A1");
item.Text = "B";
Assert.AreEqual("B", c.Text, "#B1");
Assert.AreEqual(1, c.DataBindings.Count, "c.DataBindings.Count");
BindingMemberInfo bmi = c.DataBindings[0].BindingMemberInfo;
Assert.AreEqual("Two.Three.MockItem", bmi.BindingPath, "bmi.BindingPath");
Assert.AreEqual("Two.Three.MockItem.Text", bmi.BindingMember, "bmi.BindingMember");
Assert.AreEqual("Text", bmi.BindingField, "bmi.BindingField");
}
public void FormattingEnabledTest()
{
Control c = new Control();
c.BindingContext = new BindingContext();
c.CreateControl();
MockItem item = new MockItem();
item.Value = 666;
Binding binding = new Binding("Text", item, "Value");
binding.FormattingEnabled = true;
binding.FormatString = "p";
c.DataBindings.Add(binding);
Assert.AreEqual((666).ToString("p"), c.Text, "#A1");
binding.FormatString = "c";
Assert.AreEqual((666).ToString("c"), c.Text, "#B1");
Console.WriteLine(c.Text);
binding.FormattingEnabled = false;
Assert.AreEqual((666).ToString(), c.Text, "#C1");
}
/*--------------------------------------------------------------------------------------------*/
protected void SetupFault(FabStepFault pFault, string pMessageContains)
{
MockItem
.Setup(x => x.NewStepFault(pFault.ErrCode, It.IsAny <string>(), pFault.ParamIndex, null))
.Callback((FabFault.Code c, string m, int pi, Exception e) =>
TestUtil.AssertContains("Fault.Message", m, pMessageContains))
.Returns(pFault);
}
public void TestInventoryShouldAddElementToItemsWhenItemGiven()
{
MockItem mockItem = new MockItem();
Inventory inventory = new Inventory();
inventory.addItemToInventory(mockItem);
Assert.AreEqual(1, inventory.items.Count);
}
public void ErrorAliasParamFormat()
{
MockItem.Setup(x => x.GetParamAt <string>(0)).Returns("badAL!A$");
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", 0);
SetupFault(f, "format");
CheckConsumePathThrows(f);
}
public void ErrorAliasParamLength()
{
MockItem.Setup(x => x.GetParamAt <string>(0)).Returns("abcdefghi");
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", 0);
SetupFault(f, "cannot exceed");
CheckConsumePathThrows(f);
}
public void ErrorYearParamRange(long pYear, bool pLow)
{
MockItem.Setup(x => x.GetParamAt <long>(1)).Returns(pYear);
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", 1);
SetupFault(f, (pLow ? "less" : "greater") + " than");
CheckConsumePathThrows(f);
}
public void ErrorOperationParamAccepted()
{
MockItem.Setup(x => x.GetParamAt <string>(0)).Returns("fake");
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", 0);
SetupFault(f, "Accepted values");
CheckConsumePathThrows(f);
}
public void ErrorCountParamRange(int pCount, bool pLow)
{
MockItem.Setup(x => x.GetParamAt <int>(0)).Returns(pCount);
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", 0);
SetupFault(f, (pLow ? "less" : "greater") + " than");
CheckConsumePathThrows(f);
}
public void ErrorDateParamRange(int pIndex, byte pValue, bool pLow)
{
MockItem.Setup(x => x.GetParamAt <byte>(pIndex)).Returns(pValue);
var f = new FabStepFault(FabFault.Code.IncorrectParamValue, 0, "", "", pIndex);
SetupFault(f, (pLow ? "less" : "greater") + " than");
CheckConsumePathThrows(f);
}
/*--------------------------------------------------------------------------------------------*/
protected override void CheckSuccess(bool pSuccess)
{
Times t = (pSuccess ? Times.Once() : Times.Never());
MockItem.Verify(x => x.VerifyParamCount(0, -1), Times.Once);
MockPath.Verify(x => x.AddScript(It.IsAny <string>()), Times.Never);
}
public override void SetUp()
{
base.SetUp();
vToType = typeof(FabTravFactorRoot);
vStep = new TravStepRoot <FabTravFactorRoot>("cmd");
MockItem.Setup(x => x.VerifyParamCount(0, -1));
}
public void GivenAObjWhenIsNotABoardThenDoNothing()
{
// Arrange
SetupState();
var mockItem = new MockItem();
// Act
state.Apply(mockItem);
}
public void GivenAObjWhenIsNotABoardThenDoNothing()
{
// Arrange
SetupState();
var mockItem = new MockItem();
// Act
state.Apply(mockItem);
}
public void ListChangedEventTest()
{
Control c = new Control();
c.BindingContext = new BindingContext();
c.CreateControl();
BindingListChild <MockItem> binding_list = new BindingListChild <MockItem> ();
CurrencyManager currency_manager = (CurrencyManager)c.BindingContext [binding_list];
currency_manager.ListChanged += new ListChangedEventHandler(ListChangedEvent);
ClearListChangedLog();
MockItem item = binding_list.AddNew();
binding_list.EndNew(binding_list.IndexOf(item));
Assert.IsTrue(list_changed_called, "#A1");
Assert.AreEqual(ListChangedType.ItemAdded, list_changed_args.ListChangedType, "#A2");
ClearListChangedLog();
binding_list.Insert(0, new MockItem());
Assert.IsTrue(list_changed_called, "#B1");
Assert.AreEqual(ListChangedType.ItemAdded, list_changed_args.ListChangedType, "#B2");
ClearListChangedLog();
binding_list.RemoveAt(0);
Assert.IsTrue(list_changed_called, "#D1");
Assert.AreEqual(ListChangedType.ItemDeleted, list_changed_args.ListChangedType, "#D2");
ClearListChangedLog();
binding_list [0] = new MockItem();
Assert.IsTrue(list_changed_called, "#E1");
Assert.AreEqual(ListChangedType.ItemChanged, list_changed_args.ListChangedType, "#E2");
ClearListChangedLog();
binding_list.DoResetItem(0);
Assert.IsTrue(list_changed_called, "#F1");
Assert.AreEqual(ListChangedType.ItemChanged, list_changed_args.ListChangedType, "#F2");
ClearListChangedLog();
binding_list.DoResetBinding();
Assert.IsTrue(list_changed_called, "#G1");
Assert.AreEqual(ListChangedType.Reset, list_changed_args.ListChangedType, "#G2");
binding_list.Clear();
Assert.IsTrue(list_changed_called, "#F1");
Assert.AreEqual(ListChangedType.Reset, list_changed_args.ListChangedType, "#F2");
currency_manager.ListChanged -= ListChangedEvent;
}
public void AssertValuesHaveBeenCopied()
{
var mockItem = new MockItem();
var serializableItem = new SerializableItem(mockItem);
Assert.AreEqual(mockItem.Id, serializableItem.Id);
Assert.AreEqual(mockItem.Name, serializableItem.Name);
Assert.AreEqual(mockItem.ItemCategory, serializableItem.ItemCategory);
}
public void AddingOrderInvokesPropertyChanged_PriceAndSubtotal(string property)
{
var order = new Order();
var item = new MockItem();
Assert.PropertyChanged(order, property, () =>
{
order.Add(item);
});
}
public void AcceptsType()
{
MockPath.Setup(x => x.IsAcceptableType(It.IsAny <Type>(), It.IsAny <bool>())).Returns(true);
MockPath.Setup(x => x.GetSteps(1)).Returns(Items);
MockItem.SetupGet(x => x.Command).Returns(GetStep().CommandLow);
bool result = GetStep().AcceptsPath(MockPath.Object);
Assert.True(result, "Incorrect result.");
}
public void ShouldNotHaveNegativePrice()
{
Order order = new Order();
ObservableCollection <IOrderItem> items = new ObservableCollection <IOrderItem>();
MockItem test = new MockItem();
order.Add(test);
order.Add(test);
Assert.Equal <double>(0, order.SubtotalCost);
}
private static MockItem GetParentWithChildren()
{
MockItem parent = new MockItem {
Id = "parent"
};
parent.Items.Add(new MockItem {
Id = "child1"
});
parent.Items.Add(new MockItem {
Id = "child2"
});
MockItem child3 = new MockItem {
Id = "child3"
};
parent.Items.Add(child3);
parent.Items.Add(new MockItem {
Id = "child4"
});
child3.Items.Add(new MockItem {
Id = "grandchild1"
});
MockItem grandChild2 = new MockItem {
Id = "grandchild2"
};
child3.Items.Add(grandChild2);
child3.Items.Add(new MockItem {
Id = "grandchild3"
});
child3.Items.Add(new MockItem {
Id = "grandchild4"
});
child3.Items.Add(new MockItem {
Id = "grandchild5"
});
grandChild2.Items.Add(new MockItem {
Id = "greatgrandchild1"
});
grandChild2.Items.Add(new MockItem {
Id = "greatgrandchild2"
});
grandChild2.Items.Add(new MockItem {
Id = "greatgrandchild3"
});
grandChild2.Items.Add(new MockItem {
Id = "greatgrandchild4"
});
return(parent);
}
public void SucessOperations(string pOperation)
{
vOperation = pOperation;
vScript = ".has(" + vPropDbNameParam + ", Tokens.T." + pOperation + ", " + vValueParam + ")";
MockItem.Setup(x => x.GetParamAt <string>(0)).Returns(vOperation);
MockPath.Setup(x => x.AddScript(vScript));
vStep.ConsumePath(MockPath.Object, GetToType());
CheckSuccess(true);
}
private static POSContext GenerateMockContextData()
{
var options = new DbContextOptionsBuilder <POSContext>()
.UseInMemoryDatabase("TodoList").Options;
POSContext context = new POSContext(options);
context = AddingToCartTest.AddItem(context, MockItem.GenerateMockItem1());
context = AddingToCartTest.AddItem(context, MockItem.GenerateMockItem2());
context = AddingToCartTest.AddItem(context, MockItem.GenerateMockItem3());
return(context);
}
public void GiveAObjWhenIsNotABoardThenReturnsTrue()
{
// Arrange
SetupState();
var mockItem = new MockItem();
// Act
var isAppliable = state.IsAppliable(mockItem);
// Assert
Assert.False(isAppliable);
}
public void GiveAObjWhenIsNotABoardThenReturnsTrue()
{
// Arrange
SetupState();
var mockItem = new MockItem();
// Act
var isAppliable = state.IsAppliable(mockItem);
// Assert
Assert.False(isAppliable);
}
public void SuccessNotInVertex()
{
vScript = "[0..91]";
MockPath.Setup(x => x.AddScript(vScript));
vStep = new TravStepTake <FabFactor, FabArtifact>("cmd", false);
vStep.ConsumePath(MockPath.Object, vToType);
MockItem.Verify(x => x.VerifyParamCount(1, -1), Times.Once);
MockPath.Verify(x => x.AddScript(vScript), Times.Once);
}
public void DirectStaticCall(string searchId)
{
MockItem parent = GetParentWithChildren();
MockItem result = Search.BreadthFirst(parent, p => p.Id == searchId, c => c.Items);
Assert.IsNotNull(result);
Assert.AreEqual(searchId, result.Id);
result = Search.DepthFirst(parent, p => p.Id == searchId, c => c.Items);
Assert.IsNotNull(result);
Assert.AreEqual(searchId, result.Id);
}
public void DefaultDataSourceUpdateModeTest ()
{
Control c = new Control ();
MockItem item = new MockItem ("A", -1);
Assert.AreEqual (DataSourceUpdateMode.OnValidation, c.DataBindings.DefaultDataSourceUpdateMode, "#A1");
c.DataBindings.DefaultDataSourceUpdateMode = DataSourceUpdateMode.Never;
c.DataBindings.Add (new Binding ("Name", item, "Text"));
Binding b2 = c.DataBindings.Add ("Text", item, "Text");
Binding b3 = c.DataBindings.Add ("Width", item, "Value");
Binding b4 = c.DataBindings.Add ("Height", item, "Value", true, DataSourceUpdateMode.Never);
Binding b1 = c.DataBindings [0];
Assert.AreEqual (b1.DataSourceUpdateMode, DataSourceUpdateMode.OnValidation, "#B1");
Assert.AreEqual (b2.DataSourceUpdateMode, DataSourceUpdateMode.Never, "#B2");
Assert.AreEqual (b3.DataSourceUpdateMode, DataSourceUpdateMode.Never, "#B3");
Assert.AreEqual (b4.DataSourceUpdateMode, DataSourceUpdateMode.Never, "#B4");
}
public void ShouldInitiallySetSelectedItemInSelectorFromModel()
{
var model = new MockModel();
var item1 = new MockItem { Property = 1 };
var item2 = new MockItem { Property = 2 };
var itemsSource = new List<MockItem> { item1, item2 };
var selector = new ComboBox();
selector.ItemsSource = itemsSource;
SelectorExtensions.SetSelectedValuePath(selector, "Property");
model.SelectedValueInModel = 2;
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
Assert.AreSame(item2, selector.SelectedItem);
}
public void ShouldUpdateModelOnSelectionChange()
{
var model = new MockModel();
var item1 = new MockItem { Property = 1 };
var item2 = new MockItem { Property = 2 };
var itemsSource = new List<MockItem> { item1, item2 };
var selector = new ComboBox();
selector.ItemsSource = itemsSource;
SelectorExtensions.SetSelectedValuePath(selector, "Property");
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
selector.SelectedItem = item1;
Assert.AreEqual(item1.Property, model.SelectedValueInModel);
selector.SelectedItem = item2;
Assert.AreEqual(item2.Property, model.SelectedValueInModel);
}
public void IsBindingSuspendedTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
MockItem item = new MockItem ("A", 0);
MockItem [] items = new MockItem [] { item };
BindingManagerBase manager = c.BindingContext [item];
BindingManagerBase manager2 = c.BindingContext [items];
Assert.IsFalse (manager.IsBindingSuspended, "#A1");
Assert.IsFalse (manager2.IsBindingSuspended, "#A2");
manager.SuspendBinding ();
manager2.SuspendBinding ();
Assert.IsFalse (manager.IsBindingSuspended, "#B1");
Assert.IsTrue (manager2.IsBindingSuspended, "#B2");
manager.ResumeBinding ();
manager2.ResumeBinding ();
Assert.IsFalse (manager.IsBindingSuspended, "#C1");
Assert.IsFalse (manager2.IsBindingSuspended, "#C2");
}
public async Task TestItemValidator()
{
var items = new List<MockItem>();
var pool = new PipelinedPool<MockItem>(() =>
{
var result = new MockItem();
items.Add(result);
return TaskPort.FromResult(result);
}, item => item.IsValid);
using (var item = await pool.Borrow())
{
item.Item.IsValid = false;
}
Assert.AreEqual(1, items.Count);
Assert.AreEqual(1, items.First().DisposeCount);
using (var item = await pool.Borrow())
{
item.Item.IsValid = true;
}
Assert.AreEqual(2, items.Count);
Assert.AreEqual(1, items[0].DisposeCount);
Assert.AreEqual(0, items[1].DisposeCount);
using (var item = await pool.Borrow())
{
Assert.AreSame(items[1], item.Item);
}
Assert.AreEqual(2, items.Count);
Assert.AreEqual(1, items[0].DisposeCount);
Assert.AreEqual(0, items[1].DisposeCount);
}
public void DataSourcePropertyChanged_ThreeDeep ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
One parent = new One ();
parent.Two = new Two ();
parent.Two.Three = new Three ();
parent.Two.Three.MockItem = item;
Binding binding = new Binding ("Text", parent, "Two.Three.MockItem.Text");
c.DataBindings.Add (binding);
Console.WriteLine ("c.Text: " + c.Text);
Assert.AreEqual ("A", c.Text, "#A1");
item.Text = "B";
Assert.AreEqual ("B", c.Text, "#B1");
Assert.AreEqual (1, c.DataBindings.Count, "c.DataBindings.Count");
BindingMemberInfo bmi = c.DataBindings[0].BindingMemberInfo;
Assert.AreEqual ("Two.Three.MockItem", bmi.BindingPath, "bmi.BindingPath");
Assert.AreEqual ("Two.Three.MockItem.Text", bmi.BindingMember, "bmi.BindingMember");
Assert.AreEqual ("Text", bmi.BindingField, "bmi.BindingField");
}
public void IsBindingTest ()
{
MockItem [] items = new MockItem [] { new MockItem ("A", 0) };
Binding binding = new Binding ("Text", items, "Text");
Binding binding2 = new Binding ("Text", items [0], "Text");
Assert.IsFalse (binding.IsBinding, "#A1");
Assert.IsFalse (binding2.IsBinding, "#A2");
Control c = new Control ();
Control c2 = new Control ();
c.DataBindings.Add (binding);
c2.DataBindings.Add (binding2);
Assert.IsFalse (binding.IsBinding, "#B1");
Assert.IsFalse (binding2.IsBinding, "#B2");
c.CreateControl ();
c2.CreateControl ();
Assert.IsFalse (binding.IsBinding, "#C1");
Assert.IsFalse (binding2.IsBinding, "#C2");
Form form = new Form ();
form.ShowInTaskbar = false;
form.Controls.Add (c);
form.Controls.Add (c2);
Assert.IsTrue (binding.IsBinding, "#D1");
Assert.IsTrue (binding2.IsBinding, "#D2");
form.Show ();
// Important part -
// IsBinding is true ALWAYS with PropertyManager, even when
// ResumeBinding has been called
//
CurrencyManager curr_manager = (CurrencyManager)form.BindingContext [items];
PropertyManager prop_manager = (PropertyManager)form.BindingContext [items [0]];
curr_manager.SuspendBinding ();
prop_manager.SuspendBinding ();
Assert.IsFalse (binding.IsBinding, "#E1");
Assert.IsTrue (binding2.IsBinding, "#E2");
curr_manager.ResumeBinding ();
prop_manager.ResumeBinding ();
Assert.IsTrue (binding.IsBinding, "#F1");
Assert.IsTrue (binding2.IsBinding, "#F2");
form.Dispose ();
}
public void WriteValueTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ();
item.Text = "A";
Binding binding = new Binding ("Text", item, "Text");
binding.DataSourceUpdateMode = DataSourceUpdateMode.Never;
c.DataBindings.Add (binding);
Assert.AreEqual ("A", c.Text, "#A1");
c.Text = "B";
Assert.AreEqual ("A", item.Text, "#B1");
binding.WriteValue ();
Assert.AreEqual ("B", item.Text, "#C1");
}
public void BindableComponentTest ()
{
Control c = new Control ();
MockItem item = new MockItem (String.Empty, 0);
Binding binding = new Binding ("Text", item, "Text");
c.DataBindings.Add (binding);
Assert.AreEqual (c, binding.Control, "#A1");
Assert.AreEqual (c, binding.BindableComponent, "#A2");
//
// Now use IBindableComponent - update binding when property changes
// since ToolStripItem doesn't have validation at all
//
BindableToolStripItem toolstrip_item = new BindableToolStripItem ();
toolstrip_item.BindingContext = new BindingContext ();
Binding binding2 = new Binding ("Text", item, "Text");
binding2.DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged;
item.Text = "A";
toolstrip_item.DataBindings.Add (binding2);
Assert.AreEqual (null, binding2.Control, "#B1");
Assert.AreEqual (toolstrip_item, binding2.BindableComponent, "#B2");
Assert.AreEqual (item.Text, toolstrip_item.Text, "#B3");
toolstrip_item.Text = "B";
Assert.AreEqual (toolstrip_item.Text, item.Text, "#C1");
}
public void ControlUpdateModeTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
Binding binding = new Binding ("Text", item, "Text");
binding.ControlUpdateMode = ControlUpdateMode.Never;
c.DataBindings.Add (binding);
Assert.AreEqual (String.Empty, c.Text, "#A1");
item.Text = "B";
Assert.AreEqual (String.Empty, c.Text, "#B1");
}
public void DataSourceUpdateModeTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
Binding binding = new Binding ("Text", item, "Text");
binding.DataSourceUpdateMode = DataSourceUpdateMode.Never;
c.DataBindings.Add (binding);
Assert.AreEqual ("A", c.Text, "#A1");
c.Text = "B";
Assert.AreEqual ("A", item.Text, "#B1");
binding.DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged;
Assert.AreEqual ("A", item.Text, "#C1");
c.Text = "C";
Assert.AreEqual ("C", item.Text, "#D1");
// This requires a Validation even, which we can't test
// by directly modifying the property
binding.DataSourceUpdateMode = DataSourceUpdateMode.OnValidation;
c.Text = "D";
Assert.AreEqual ("C", item.Text, "#E1");
}
public void FormattingEnabledTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ();
item.Value = 666;
Binding binding = new Binding ("Text", item, "Value");
binding.FormattingEnabled = true;
binding.FormatString = "p";
c.DataBindings.Add (binding);
Assert.AreEqual ((666).ToString ("p"), c.Text, "#A1");
binding.FormatString = "c";
Assert.AreEqual ((666).ToString ("c"), c.Text, "#B1");
Console.WriteLine (c.Text);
binding.FormattingEnabled = false;
Assert.AreEqual ((666).ToString (), c.Text, "#C1");
}
public void DataSourcePropertyChanged_Original ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
Binding binding = new Binding ("Text", item, "Text");
c.DataBindings.Add (binding);
Assert.AreEqual ("A", c.Text, "#A1");
item.Text = "B";
Assert.AreEqual ("B", c.Text, "#B1");
}
public void ShouldNotFailIfItemsSourceIsNotSetBeforeSettingTheBindingToModel()
{
var model = new MockModel();
var item1 = new MockItem { Property = 1 };
var item2 = new MockItem { Property = 2 };
var itemsSource = new List<MockItem> { item1, item2 };
var selector = new ComboBox();
SelectorExtensions.SetSelectedValuePath(selector, "Property");
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
selector.ItemsSource = itemsSource;
}
public void DataSourcePropertyChanged_OneDeep ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
One parent = new One ();
parent.MockItem = item;
Binding binding = new Binding ("Text", parent, "MockItem.Text");
c.DataBindings.Add (binding);
Assert.AreEqual ("A", c.Text, "#A1");
item.Text = "B";
Assert.AreEqual ("B", c.Text, "#B1");
}
public void InvalidValuePathThrows()
{
var model = new MockModel();
var item1 = new MockItem { Property = 1 };
var itemsSource = new List<MockItem> { item1 };
var selector = new ComboBox();
selector.ItemsSource = itemsSource;
Binding valueBinding = new Binding("SelectedValueInModel");
valueBinding.Mode = BindingMode.TwoWay;
valueBinding.Source = model;
selector.SetBinding(SelectorExtensions.SelectedValueProperty, valueBinding);
SelectorExtensions.SetSelectedValuePath(selector, "InvalidProperty");
}
public void VerifyWhiteSpaceCharactersAreIgnoredInCommandText()
{
var cat = new MockItem("Cat", "animal");
var dog = new MockItem("Dog", "animal");
var camry = new MockItem("Camry", "car");
var ford = new MockItem("Ford", "car");
var cherryTree = new MockItem("Cherry Tree", "plant");
var grass = new MockItem("Grass", "plant");
List<object> items = new List<object>() { cat, dog, camry, ford, cherryTree, grass };
AutoCompleteTextBox textBox = GetAutoCompleteTextBox(items);
textBox.FilterCommands = new List<IFilterCommand>() { new AnimalFilterCommand() };
textBox.SetText("animal: C");
Assert.IsTrue(textBox.IsDropDownVisible);
Assert.AreElementsSame(new List<MockItem>() { cat }, textBox.FilteredItems.Cast<MockItem>());
textBox.SetText("");
Assert.IsFalse(textBox.IsDropDownVisible);
Assert.AreElementsSame(new List<MockItem>(), textBox.FilteredItems.Cast<MockItem>());
textBox.SetText(" animal:C");
Assert.IsTrue(textBox.IsDropDownVisible);
Assert.AreElementsSame(new List<MockItem>() { cat }, textBox.FilteredItems.Cast<MockItem>());
}
public void TestIndexerWithMember ()
{
BindingContext bc = new BindingContext ();
ArrayList data_source = new ArrayList ();
BindingManagerBase a, b, c, d;
data_source.AddRange (new string [] { "1", "2", "3", "4", "5" });
a = bc [data_source, "Length"];
b = bc [data_source, "Length"];
Assert.AreSame (a, b, "INWM1");
b = bc [data_source];
Assert.IsFalse (object.ReferenceEquals (a, b), "INWM2");
c = bc [data_source];
Assert.AreSame (b, c, "INWM3");
b = bc [data_source, "Length"];
Assert.AreSame (a, b, "INWM4");
// Non List type
MockItem item = new MockItem ("Mono", -1);
MockContainer container = new MockContainer ();
container.Item = item;
d = bc [container, "Item.Text"];
Assert.AreEqual ("Mono", d.Current, "INWM5");
Assert.AreEqual (1, d.Count, "INWM6");
Assert.AreEqual (0, d.Position, "INWM7");
d = bc [container, "Item.Text.Length"];
Assert.AreEqual (4, d.Current, "INWM8");
Assert.AreEqual (1, d.Count, "INWM9");
Assert.AreEqual (0, d.Position, "INWM10");
}
public void DataSourcePropertyChanged_Original_BadName ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
MockItem item = new MockItem ("A", 0);
Binding binding = new Binding ("Text", item, "xxxxxxTextXXXXX");
try {
c.DataBindings.Add (binding);
Assert.Fail ("exc1");
} catch (ArgumentException ex) {
Assert.AreEqual ("dataMember", ex.ParamName, "ex.ParamName"); // (test is not locale dependent)
}
}
