Files
mono/mcs/class/System/Test/System.ComponentModel/BindingListTest.cs
T
Chris Toshok d350d3e221 In Test/System.ComponentModel:
2007-01-20  Chris Toshok  <[email protected]>

	* BindingListTest.cs: new tests for BindingList<T>

In System.ComponentModel:
2007-01-20  Chris Toshok  <[email protected]>

	* BindingList.cs: new class.


svn path=/trunk/mcs/; revision=71405
2007-01-21 03:48:03 +00:00

592 lines
16 KiB
C#

#if NET_2_0
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Collections.Generic;
using NUnit.Framework;
namespace MonoTests.System.ComponentModel
{
[TestFixture]
public class BindingListTest
{
[Test]
public void BindingListDefaults ()
{
BindingList<string> l = new BindingList<string> ();
IBindingList ibl = (IBindingList)l;
Assert.IsTrue (l.AllowEdit, "1");
Assert.IsFalse (l.AllowNew, "2");
Assert.IsTrue (l.AllowRemove, "3");
Assert.IsTrue (l.RaiseListChangedEvents, "4");
Assert.IsFalse (ibl.IsSorted, "5");
Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
Assert.IsTrue (ibl.SupportsChangeNotification, "7");
Assert.IsFalse (ibl.SupportsSearching, "8");
Assert.IsFalse (ibl.SupportsSorting, "9");
Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
}
[Test]
public void BindingListDefaults_FixedSizeList ()
{
string[] arr = new string[10];
BindingList<string> l = new BindingList<string> (arr);
IBindingList ibl = (IBindingList)l;
Assert.IsTrue (l.AllowEdit, "1");
Assert.IsFalse (l.AllowNew, "2");
Assert.IsTrue (l.AllowRemove, "3");
Assert.IsTrue (l.RaiseListChangedEvents, "4");
Assert.IsFalse (ibl.IsSorted, "5");
Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
Assert.IsTrue (ibl.SupportsChangeNotification, "7");
Assert.IsFalse (ibl.SupportsSearching, "8");
Assert.IsFalse (ibl.SupportsSorting, "9");
Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
}
[Test]
public void BindingListDefaults_NonFixedSizeList ()
{
List<string> list = new List<string> ();
BindingList<string> l = new BindingList<string> (list);
IBindingList ibl = (IBindingList)l;
Assert.IsTrue (l.AllowEdit, "1");
Assert.IsFalse (l.AllowNew, "2");
Assert.IsTrue (l.AllowRemove, "3");
Assert.IsTrue (l.RaiseListChangedEvents, "4");
Assert.IsFalse (ibl.IsSorted, "5");
Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
Assert.IsTrue (ibl.SupportsChangeNotification, "7");
Assert.IsFalse (ibl.SupportsSearching, "8");
Assert.IsFalse (ibl.SupportsSorting, "9");
Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
}
[Test]
public void BindingListDefaults_ReadOnlyList ()
{
List<string> list = new List<string> ();
BindingList<string> l = new BindingList<string> (list);
IBindingList ibl = (IBindingList)l;
Assert.IsTrue (l.AllowEdit, "1");
Assert.IsFalse (l.AllowNew, "2");
Assert.IsTrue (l.AllowRemove, "3");
Assert.IsTrue (l.RaiseListChangedEvents, "4");
Assert.IsFalse (ibl.IsSorted, "5");
Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
Assert.IsTrue (ibl.SupportsChangeNotification, "7");
Assert.IsFalse (ibl.SupportsSearching, "8");
Assert.IsFalse (ibl.SupportsSorting, "9");
Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
}
[Test]
public void TestAllowNew ()
{
/* Object has a default ctor */
BindingList<object> l1 = new BindingList<object> ();
Assert.IsTrue (l1.AllowNew, "1");
/* string has no default ctor */
BindingList<string> l2 = new BindingList<string> ();
Assert.IsFalse (l2.AllowNew, "2");
/* adding a delegate to AddingNew fixes that */
l2.AddingNew += delegate (object sender, AddingNewEventArgs e) { };
Assert.IsTrue (l2.AllowNew, "3");
l1 = new BindingList<object> ();
bool list_changed = false;
bool expected = false;
l1.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
Assert.AreEqual (-1, e.NewIndex, "4");
Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "5");
Assert.AreEqual (expected, l1.AllowNew, "6");
};
expected = false;
l1.AllowNew = false;
Assert.IsTrue (list_changed, "7");
/* the default for T=object is true, so check
if we enter the block for raising the event
if we explicitly set it to the value it
currently has. */
l1 = new BindingList<object> ();
list_changed = false;
l1.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
Assert.AreEqual (-1, e.NewIndex, "8");
Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "9");
Assert.AreEqual (expected, l1.AllowNew, "10");
};
expected = true;
l1.AllowNew = true;
/* turns out it doesn't raise the event, so the check must only be for "allow_new == value" */
Assert.IsFalse (list_changed, "11");
}
[Test]
public void TestResetBindings ()
{
BindingList<object> l = new BindingList<object> ();
bool list_changed = false;
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
Assert.AreEqual (-1, e.NewIndex, "1");
Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
};
l.ResetBindings ();
Assert.IsTrue (list_changed, "3");
}
[Test]
public void TestResetItem ()
{
List<object> list = new List<object>();
list.Add (new object());
BindingList<object> l = new BindingList<object> (list);
bool item_changed = false;
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
item_changed = true;
Assert.AreEqual (0, e.NewIndex, "1");
Assert.AreEqual (ListChangedType.ItemChanged, e.ListChangedType, "2");
};
l.ResetItem (0);
Assert.IsTrue (item_changed, "3");
}
[Test]
public void TestRemoveItem ()
{
List<object> list = new List<object>();
list.Add (new object());
BindingList<object> l = new BindingList<object> (list);
bool item_deleted = false;
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
item_deleted = true;
Assert.AreEqual (0, e.NewIndex, "1");
Assert.AreEqual (ListChangedType.ItemDeleted, e.ListChangedType, "2");
Assert.AreEqual (0, l.Count, "3"); // to show the event is raised after the removal
};
l.RemoveAt (0);
Assert.IsTrue (item_deleted, "4");
}
[Test]
[ExpectedException (typeof (NotSupportedException))]
public void TestRemoveItem_AllowRemoveFalse ()
{
List<object> list = new List<object>();
list.Add (new object());
BindingList<object> l = new BindingList<object> (list);
l.AllowRemove = false;
l.RemoveAt (0);
}
[Test]
public void TestAllowEditEvent ()
{
BindingList<object> l = new BindingList<object>();
bool event_raised = false;
bool expected = false;
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
event_raised = true;
Assert.AreEqual (-1, e.NewIndex, "1");
Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
Assert.AreEqual (expected, l.AllowEdit, "3");
};
expected = false;
l.AllowEdit = false;
Assert.IsTrue (event_raised, "4");
// check to see if RaiseListChangedEvents affects AllowEdit's event.
l.RaiseListChangedEvents = false;
event_raised = false;
expected = true;
l.AllowEdit = true;
Assert.IsFalse (event_raised, "5");
}
[Test]
public void TestAllowRemove ()
{
BindingList<object> l = new BindingList<object>();
bool event_raised = false;
bool expected = false;
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
event_raised = true;
Assert.AreEqual (-1, e.NewIndex, "1");
Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
Assert.AreEqual (expected, l.AllowRemove, "3");
};
expected = false;
l.AllowRemove = false;
Assert.IsTrue (event_raised, "4");
// check to see if RaiseListChangedEvents affects AllowRemove's event.
l.RaiseListChangedEvents = false;
event_raised = false;
expected = true;
l.AllowRemove = true;
Assert.IsFalse (event_raised, "5");
}
[Test]
public void TestAddNew_SettingArgsNewObject ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
e.NewObject = o;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.AreSame (o, rv, "3");
}
[Test]
public void TestAddNew ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
}
[Test]
public void TestAddNew_Cancel ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
Assert.AreEqual (1, l.Count, "4");
Assert.AreEqual (0, l.IndexOf (rv), "5");
Assert.IsTrue (list_changed, "6");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
Assert.AreEqual (0, list_changed_index, "8");
list_changed = false;
l.CancelNew (0);
Assert.AreEqual (0, l.Count, "9");
Assert.IsTrue (list_changed, "10");
Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "11");
Assert.AreEqual (0, list_changed_index, "12");
}
[Test]
public void TestAddNew_CancelDifferentIndex ()
{
List<object> list = new List<object>();
list.Add (new object ());
list.Add (new object ());
BindingList<object> l = new BindingList<object>(list);
bool adding_event_raised = false;
object o = new object ();
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
Assert.AreEqual (3, l.Count, "4");
Assert.AreEqual (2, l.IndexOf (rv), "5");
Assert.IsTrue (list_changed, "6");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
Assert.AreEqual (2, list_changed_index, "8");
list_changed = false;
l.CancelNew (0);
Assert.IsFalse (list_changed, "9");
Assert.AreEqual (3, l.Count, "10");
l.CancelNew (2);
Assert.IsTrue (list_changed, "11");
Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "12");
Assert.AreEqual (2, list_changed_index, "13");
Assert.AreEqual (2, l.Count, "14");
}
[Test]
public void TestAddNew_End ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
Assert.AreEqual (1, l.Count, "4");
Assert.AreEqual (0, l.IndexOf (rv), "5");
Assert.IsTrue (list_changed, "6");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
Assert.AreEqual (0, list_changed_index, "8");
list_changed = false;
l.EndNew (0);
Assert.AreEqual (1, l.Count, "9");
Assert.IsFalse (list_changed, "10");
}
[Test]
public void TestAddNew_CancelDifferentIndexThenEnd ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
Assert.AreEqual (1, l.Count, "4");
Assert.AreEqual (0, l.IndexOf (rv), "5");
Assert.IsTrue (list_changed, "6");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
Assert.AreEqual (0, list_changed_index, "8");
list_changed = false;
l.CancelNew (2);
Assert.AreEqual (1, l.Count, "9");
Assert.IsFalse (list_changed, "10");
l.EndNew (0);
Assert.AreEqual (1, l.Count, "11");
Assert.IsFalse (list_changed, "12");
}
[Test]
public void TestAddNew_EndDifferentIndexThenCancel ()
{
BindingList<object> l = new BindingList<object>();
bool adding_event_raised = false;
object o = new object ();
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
Assert.IsNull (e.NewObject, "1");
};
l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object rv = l.AddNew ();
Assert.IsTrue (adding_event_raised, "2");
Assert.IsNotNull (rv, "3");
Assert.AreEqual (1, l.Count, "4");
Assert.AreEqual (0, l.IndexOf (rv), "5");
Assert.IsTrue (list_changed, "6");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
Assert.AreEqual (0, list_changed_index, "8");
list_changed = false;
l.EndNew (2);
Assert.AreEqual (1, l.Count, "9");
Assert.IsFalse (list_changed, "10");
l.CancelNew (0);
Assert.IsTrue (list_changed, "11");
Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "12");
Assert.AreEqual (0, list_changed_index, "13");
}
class BindingListPoker : BindingList<object>
{
public object DoAddNewCore()
{
return base.AddNewCore ();
}
}
// test to make sure that the events are raised in AddNewCore and not in AddNew
[Test]
public void TestAddNewCore_Insert ()
{
BindingListPoker poker = new BindingListPoker ();
bool adding_event_raised = false;
bool list_changed = false;
ListChangedType change_type = ListChangedType.Reset;
int list_changed_index = -1;
poker.AddingNew += delegate (object sender, AddingNewEventArgs e) {
adding_event_raised = true;
};
poker.ListChanged += delegate (object sender, ListChangedEventArgs e) {
list_changed = true;
change_type = e.ListChangedType;
list_changed_index = e.NewIndex;
};
object o = poker.DoAddNewCore ();
Assert.IsTrue (adding_event_raised, "1");
Assert.IsTrue (list_changed, "2");
Assert.AreEqual (ListChangedType.ItemAdded, change_type, "3");
Assert.AreEqual (0, list_changed_index, "4");
Assert.AreEqual (1, poker.Count, "5");
}
}
}
#endif