diff options
Diffstat (limited to 'Xamarin.Forms.Core.UnitTests/TemplatedItemsListTests.cs')
| -rw-r--r-- | Xamarin.Forms.Core.UnitTests/TemplatedItemsListTests.cs | 1073 |
1 files changed, 1073 insertions, 0 deletions
diff --git a/Xamarin.Forms.Core.UnitTests/TemplatedItemsListTests.cs b/Xamarin.Forms.Core.UnitTests/TemplatedItemsListTests.cs new file mode 100644 index 00000000..d723b660 --- /dev/null +++ b/Xamarin.Forms.Core.UnitTests/TemplatedItemsListTests.cs @@ -0,0 +1,1073 @@ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Linq; +using NUnit.Framework; + +namespace Xamarin.Forms.Core.UnitTests +{ + [TestFixture] + public class TemplatedItemsListTests : BaseTestFixture + { + class MockItemsView + : ItemsView<BindableObject> + { + public MockItemsView() + { + TemplatedItems.IsGroupingEnabledProperty = IsGroupingEnabledProperty; + } + + public event Action<BindableObject> Hooked; + public event Action<BindableObject> Unhooked; + + public static readonly BindableProperty IsGroupingEnabledProperty = + BindableProperty.Create<MockItemsView, bool> (lv => lv.IsGroupingEnabled, false); + + public bool IsGroupingEnabled + { + get { return (bool)GetValue (IsGroupingEnabledProperty); } + set { SetValue (IsGroupingEnabledProperty, value); } + } + + protected override BindableObject CreateDefault (object item) + { + return new TextCell { Text = item.ToString () }; + } + + public new TemplatedItemsList<ItemsView<BindableObject>, BindableObject> TemplatedItems + { + get { return base.TemplatedItems; } + } + + BindingBase groupShortNameBinding; + public BindingBase GroupShortNameBinding + { + get { return groupShortNameBinding; } + set { + if (groupShortNameBinding == value) + return; + OnPropertyChanging (); + groupShortNameBinding = value; + TemplatedItems.GroupShortNameBinding = value; + OnPropertyChanged (); + } + } + + BindingBase groupDisplayBinding; + public BindingBase GroupDisplayBinding + { + get { return groupDisplayBinding; } + set { + if (groupDisplayBinding == value) + return; + + OnPropertyChanging (); + groupDisplayBinding = value; + TemplatedItems.GroupDisplayBinding = value; + OnPropertyChanged (); + } + } + + protected override void SetupContent (BindableObject content, int index) + { + base.SetupContent (content, index); + + if (Hooked != null) + Hooked (content); + } + + protected override void UnhookContent (BindableObject content) + { + base.UnhookContent (content); + + if (Unhooked != null) + Unhooked (content); + } + } + + [SetUp] + public override void Setup() + { + base.Setup (); + bindable = new MockItemsView(); + + Device.PlatformServices = new MockPlatformServices (); + } + + [TearDown] + public override void TearDown() + { + base.TearDown (); + Device.PlatformServices = null; + } + + MockItemsView bindable; + + [Test] + public void ListProxyNotNullWithNullItemsSource() + { + Assert.IsNotNull (bindable.TemplatedItems.ListProxy); + } + + [Test] + public void ResetOnItemsSourceChanged() + { + bool raised = false; + NotifyCollectionChangedAction action = default(NotifyCollectionChangedAction); + bindable.TemplatedItems.CollectionChanged += (sender, args) => { + raised = true; + action = args.Action; + }; + + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, Enumerable.Empty<string>()); + + Assert.IsTrue (raised, "CollectionChanged was not raised"); + Assert.AreEqual (NotifyCollectionChangedAction.Reset, action); + } + /* + [Test] + public void ResetOnInfiniteScrollingChanged() + { + bool raised = false; + NotifyCollectionChangedAction action = default(NotifyCollectionChangedAction); + bindable.TemplatedItems.CollectionChanged += (sender, args) => { + raised = true; + action = args.Action; + }; + + bindable.SetValue (ItemsView.InfiniteScrollingProperty, true); + + Assert.IsTrue (raised, "CollectionChanged was not raised"); + Assert.AreEqual (NotifyCollectionChangedAction.Reset, action); + }*/ + + [Test] + public void ResetOnTemplateChanged() + { + // Template changes won't trigger a reset if there's no items. + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, new[] { "Foo" }); + + bool raised = false; + NotifyCollectionChangedAction action = default(NotifyCollectionChangedAction); + bindable.TemplatedItems.CollectionChanged += (sender, args) => { + raised = true; + action = args.Action; + }; + + bindable.SetValue (ItemsView<BindableObject>.ItemTemplateProperty, new DataTemplate()); + + Assert.IsTrue (raised, "CollectionChanged was not raised"); + Assert.AreEqual (NotifyCollectionChangedAction.Reset, action); + } + + [Test] + public void PassThroughChanges() + { + var collection = new ObservableCollection<string>(); + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + bool raised = false; + NotifyCollectionChangedEventArgs args = null; + bindable.TemplatedItems.CollectionChanged += (sender, eventArgs) => { + raised = true; + args = eventArgs; + }; + + string str = "foo bar"; + collection.Add (str); + + Assert.IsTrue (raised, "CollectionChanged was not raised"); + Assert.AreEqual (NotifyCollectionChangedAction.Add, args.Action); + Assert.AreEqual (0, args.NewStartingIndex); + Assert.IsNotNull (args.NewItems); + Assert.AreEqual (1, args.NewItems.Count); + Assert.AreSame (str, ((Cell)args.NewItems[0]).BindingContext); + } + + [Test] + public void ListProxyUpdatesWithItemsSource() + { + var collection = new List<string> { "foo bar" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + Assert.IsNotNull (bindable.TemplatedItems.ListProxy); + Assert.AreEqual (collection.Count, bindable.TemplatedItems.ListProxy.Count); + } + + [Test] + public void GetOrCreateContent ([Values (0, 1, 2)] int index) + { + var collection = new List<string> { "foo", "bar", "baz" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + DataTemplate template = new DataTemplate (typeof (TextCell)); + template.SetBinding (TextCell.TextProperty, new Binding (".")); + bindable.SetValue (ItemsView<BindableObject>.ItemTemplateProperty, template); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.IsNotNull (content); + + TextCell textCell = content as TextCell; + Assert.IsNotNull (textCell, "Content was did not match the template type, expected {0} but got {1}", typeof(TextCell), content.GetType()); + + Assert.AreSame (collection[index], textCell.BindingContext); + Assert.AreSame (collection[index], textCell.Text); + + BindableObject content2 = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.AreSame (content, content2); + } + + [Test] + public void GetOrCreateContentDefault() + { + Assert.IsNull (bindable.GetValue (ItemsView<BindableObject>.ItemTemplateProperty)); + + var collection = new List<string> { "foo", "bar", "baz" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + const int index = 0; + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.IsNotNull (content); + + TextCell textCell = content as TextCell; + Assert.IsNotNull (textCell, "Content was did not match the template type, expected {0} but got {1}", typeof(TextCell), content.GetType()); + + Assert.AreSame (collection[index], textCell.BindingContext); + Assert.AreSame (collection[index], textCell.Text); + + BindableObject content2 = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.AreSame (content, content2); + } + + [Test] + public void GetOrCreateContentAfterTemplateChange() + { + var collection = new List<string> { "foo", "bar", "baz" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + const int index = 0; + + DataTemplate template = new DataTemplate (typeof (TextCell)); + template.SetBinding (TextCell.TextProperty, new Binding (".")); + bindable.SetValue (ItemsView<BindableObject>.ItemTemplateProperty, template); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.That (content, Is.InstanceOf<TextCell>()); + + template = new DataTemplate (typeof (SwitchCell)); + template.SetBinding (SwitchCell.TextProperty, new Binding (".")); + + bindable.SetValue (ItemsView<BindableObject>.ItemTemplateProperty, template); + + BindableObject content2 = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.IsNotNull (content2); + Assert.That (content2, Is.InstanceOf<SwitchCell>()); + + var switchCell = (SwitchCell) content2; + Assert.AreSame (collection[index], switchCell.BindingContext); + } + + [Test] + public void GetOrCreateContentAfterItemsSourceChanged() + { + var collection = new List<string> { "foo", "bar", "baz" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + const int index = 0; + + DataTemplate template = new DataTemplate (typeof (TextCell)); + template.SetBinding (TextCell.TextProperty, new Binding (".")); + bindable.SetValue (ItemsView<BindableObject>.ItemTemplateProperty, template); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + Assert.IsNotNull (content); + + collection = new List<string> { "we", "wee", "weee" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + var content2 = (TextCell)bindable.TemplatedItems.GetOrCreateContent (index, collection[index]); + + Assert.AreNotSame (content, content2); + Assert.AreSame (collection[index], content2.BindingContext); + Assert.AreSame (collection[index], content2.Text); + } + + /*[Test] + public void GetOrCreateContentAfterInfiniteScrollingChanged() + { + var collection = new List<string> { "foo", "bar", "baz" }; + bindable.SetValue (ItemsView.ItemsSourceProperty, collection); + + const int index = 0; + + DataTemplate template = new DataTemplate (typeof (TextCell)); + template.SetBinding (TextCell.TextProperty, new Binding (".")); + bindable.SetValue (ItemsView.ItemTemplateProperty, template); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (index, collection[index], o => new TextCell (o.ToString())); + Assert.IsNotNull (content); + + bindable.SetValue (ItemsView.InfiniteScrollingProperty, true); + + var content2 = (TextCell)bindable.TemplatedItems.GetOrCreateContent (index, collection[index], o => new TextCell (o.ToString())); + + Assert.AreNotSame (content, content2); + Assert.AreSame (collection[index], content2.BindingContext); + Assert.AreSame (collection[index], content2.Text); + }*/ + + [Test] + [Description ("Make sure we're not duplicate cell instances for an equal item if it's a different index")] + public void GetOrCreateContentEqualItemDifferentItemDifferentIndex() + { + Assert.IsNull (bindable.GetValue (ItemsView<BindableObject>.ItemTemplateProperty)); + + var collection = new List<string> { "foo", "foo" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (0, collection[0]); + Assert.IsNotNull (content); + + TextCell textCell = content as TextCell; + Assert.IsNotNull (textCell, "Content was did not match the template type, expected {0} but got {1}", typeof(TextCell), content.GetType()); + + Assert.AreSame (collection[0], textCell.BindingContext); + Assert.AreSame (collection[0], textCell.Text); + + BindableObject content2 = bindable.TemplatedItems.GetOrCreateContent (1, collection[1]); + Assert.AreNotSame (content, content2); + + Assert.AreSame (collection[1], textCell.BindingContext); + Assert.AreSame (collection[1], textCell.Text); + } + + [Test] + [Description ("Make sure we're not duplicate cell instances for the same item if it's a different index")] + public void GetOrCreateContentEqualItemSameItemDifferentIndex() + { + Assert.IsNull (bindable.GetValue (ItemsView<BindableObject>.ItemTemplateProperty)); + + string item = "foo"; + + var collection = new List<string> { item, item }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + BindableObject content = bindable.TemplatedItems.GetOrCreateContent (0, item); + Assert.IsNotNull (content); + + TextCell textCell = content as TextCell; + Assert.IsNotNull (textCell, "Content was did not match the template type, expected {0} but got {1}", typeof(TextCell), content.GetType()); + + Assert.AreSame (item, textCell.BindingContext); + Assert.AreSame (item, textCell.Text); + + BindableObject content2 = bindable.TemplatedItems.GetOrCreateContent (1, item); + Assert.AreNotSame (content, content2); + + Assert.AreSame (item, textCell.BindingContext); + Assert.AreSame (item, textCell.Text); + } + + [Test] + public void ItemsSourceInsertPreRealzied() + { + var collection = new ObservableCollection<string> { "foo", "bar" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + collection.Insert (1, "baz"); + + Assert.That (bindable.TemplatedItems.Count, Is.EqualTo (3)); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (0, collection[0]).BindingContext, Is.SameAs (collection[0])); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (1, collection[1]).BindingContext, Is.SameAs (collection[1])); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (2, collection[2]).BindingContext, Is.SameAs (collection[2])); + } + + [Test] + public void ItemsSourceInsertPostRealized() + { + var collection = new ObservableCollection<string> { "foo", "bar" }; + bindable.SetValue (ItemsView<BindableObject>.ItemsSourceProperty, collection); + + // Force the handler to realize/create the content + bindable.TemplatedItems.GetOrCreateContent (0, collection[0]); + bindable.TemplatedItems.GetOrCreateContent (1, collection[1]); + + collection.Insert (1, "baz"); + + Assert.That (bindable.TemplatedItems.Count, Is.EqualTo (3)); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (0, collection[0]).BindingContext, Is.SameAs (collection[0])); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (1, collection[1]).BindingContext, Is.SameAs (collection[1])); + Assert.That (bindable.TemplatedItems.GetOrCreateContent (2, collection[2]).BindingContext, Is.SameAs (collection[2])); + } + + [TestCase (0, 0, 0)] + [TestCase (3, 1, 0)] + public void GetGroupIndexFromGlobalGroupIndex (int globalIndex, int expectedIndex, int expectedLeftOver) + { + var collection = new[] { + new[] { "foo", "fad" }, + new[] { "bar", "baz" } + }; + bindable.ItemsSource = collection; + bindable.IsGroupingEnabled = true; + + int leftOver; + int index = bindable.TemplatedItems.GetGroupIndexFromGlobal (globalIndex, out leftOver); + Assert.That (index, Is.EqualTo (expectedIndex)); + Assert.That (leftOver, Is.EqualTo (expectedLeftOver)); + } + + [TestCase (1, 0, 1)] + [TestCase (2, 0, 2)] + [TestCase (4, 1, 1)] + [TestCase (5, 1, 2)] + public void GetGroupIndexFromGlobalItemIndex (int globalIndex, int expectedIndex, int expectedLeftOver) + { + var collection = new[] { + new[] { "foo", "fad" }, + new[] { "bar", "baz" } + }; + bindable.ItemsSource = collection; + bindable.IsGroupingEnabled = true; + + int leftOver; + int index = bindable.TemplatedItems.GetGroupIndexFromGlobal (globalIndex, out leftOver); + Assert.That (index, Is.EqualTo (expectedIndex)); + Assert.That (leftOver, Is.EqualTo (expectedLeftOver)); + } + + [Test] + public void GetGroupAndIndexOfItem ([Values (0, 1, 2)] int group, [Values (0, 1, 2)] int index) + { + var collection = new[] { + new[] { "foo", "fad" }, + new[] { "bar", "baz" } + }; + bindable.ItemsSource = collection; + bindable.IsGroupingEnabled = true; + + object item = null; + if (group < collection.Length) { + if (index < collection[group].Length) + item = collection[group][index]; + } + + if (item == null) { + item = "not in here"; + group = index = -1; + } + + var location = bindable.TemplatedItems.GetGroupAndIndexOfItem (item); + Assert.That (location.Item1, Is.EqualTo (group), "Group index was incorrect"); + Assert.That (location.Item2, Is.EqualTo (index), "Item index was incorrect"); + } + + [Test] + public void GetGroupAndIndexOfItemNotGrouped () + { + var items = Enumerable.Range (0, 10).ToList (); + bindable.ItemsSource = items; + + var location = bindable.TemplatedItems.GetGroupAndIndexOfItem (null, items[2]); + + Assert.That (location.Item1, Is.EqualTo (0)); + Assert.That (location.Item2, Is.EqualTo (2)); + } + + [Test] + public void ItemsSourcePropertyChangedWithBindable() + { + bool raised = false; + bindable.TemplatedItems.PropertyChanged += (s, e) => { + if (e.PropertyName == "ItemsSource") + raised = true; + }; + + bindable.ItemsSource = new object[0]; + + Assert.That (raised, Is.True, "INPC not raised for ItemsSource"); + } + + [Test] + public void IndexCorrectAfterMovingGroups() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.IsGroupingEnabled = true; + + items.Move (0, 1); + + var til = bindable.TemplatedItems.GetGroup (1); + int index = GetIndex (til.HeaderContent); + + Assert.That (index, Is.EqualTo (1)); + } + + [Test] + public void ShortNameSetBeforeGrouping() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupDisplayBinding = new Binding (".[0]"); + bindable.GroupShortNameBinding = new Binding (".[0]"); + bindable.IsGroupingEnabled = true; + + Assert.That (bindable.TemplatedItems.ShortNames[0], Is.EqualTo ("foo")); + } + + [Test] + public void ItemAddedWithShortNameSetButUngrouped() + { + var items = new ObservableCollection<string> { "foo", "bar" }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + + Assert.That (() => items.Add ("baz"), Throws.Nothing); + } + + [Test] + public void ItemAddedWithShortNameSetButGroupingDisabled() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + bindable.IsGroupingEnabled = false; + + Assert.That (() => items.Add (new ObservableCollection<string>()), Throws.Nothing); + } + + int GetIndex (BindableObject item) + { + return TemplatedItemsList<ItemsView<BindableObject>, BindableObject>.GetIndex (item); + } + + [Test] + public void GetIndex() + { + var items = new List<string> { "foo", "bar", "baz" }; + + bindable.ItemsSource = items; + + BindableObject item = bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + int index = GetIndex (item); + Assert.That (index, Is.EqualTo (1)); + } + + [Test] + public void GetIndexAfterInsert() + { + var items = new ObservableCollection<string> { "foo", "bar", "baz" }; + + bindable.ItemsSource = items; + + BindableObject originalItem = bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + items.Insert (1, "fad"); + + BindableObject item = bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + int index = GetIndex (item); + Assert.That (index, Is.EqualTo (1)); + + index = GetIndex (originalItem); + Assert.That (index, Is.EqualTo (2)); + } + + [Test] + public void GetIndexAfterMove() + { + var items = new ObservableCollection<string> { "foo", "bar", "baz" }; + + bindable.ItemsSource = items; + + BindableObject item0 = bindable.TemplatedItems.GetOrCreateContent (0, items[0]); + BindableObject item1 = bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + BindableObject item2 = bindable.TemplatedItems.GetOrCreateContent (2, items[2]); + + items.Move (0, 2); // foo, bar, baz becomes bar (1), baz (2), foo (0) + + Assert.That (GetIndex (item0), Is.EqualTo (2)); + Assert.That (GetIndex (item1), Is.EqualTo (0)); + Assert.That (GetIndex (item2), Is.EqualTo (1)); + } + + [Test] + public void GetIndexAfterRemove() + { + var items = new ObservableCollection<string> { "foo", "bar", "baz" }; + + bindable.ItemsSource = items; + + BindableObject item1 = bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + BindableObject item2 = bindable.TemplatedItems.GetOrCreateContent (2, items[2]); + + items.RemoveAt (0); + + Assert.That (GetIndex (item1), Is.EqualTo (0)); + Assert.That (GetIndex (item2), Is.EqualTo (1)); + } + + [Test] + public void GetGroup() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var til = bindable.TemplatedItems.GetGroup (1); + var item = til[1]; + + var group = TemplatedItemsList<ItemsView<BindableObject>, BindableObject>.GetGroup (item); + + Assert.That (group, Is.SameAs (til)); + } + + [Test] + public void GetIndexGrouped() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var til = bindable.TemplatedItems.GetGroup (1); + var item = til[1]; + + int index = GetIndex (item); + Assert.That (index, Is.EqualTo (1)); + } + + [Test] + public void GetGroupAndIndexOfItem() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var result = bindable.TemplatedItems.GetGroupAndIndexOfItem (items[1], items[1][1]); + + Assert.That (result.Item1, Is.EqualTo (1)); + Assert.That (result.Item2, Is.EqualTo (1)); + } + + [Test] + public void GetGroupAndIndexOfItemNoGroup() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var result = bindable.TemplatedItems.GetGroupAndIndexOfItem (null, items[1][1]); + + Assert.That (result.Item1, Is.EqualTo (1)); + Assert.That (result.Item2, Is.EqualTo (1)); + } + + [Test] + public void GetGroupAndIndexOfItemNotFound() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var group = new ObservableCollection<string> { "bam" }; + + var result = bindable.TemplatedItems.GetGroupAndIndexOfItem (group, group[0]); + + Assert.That (result.Item1, Is.EqualTo (-1)); + Assert.That (result.Item2, Is.EqualTo (-1)); + } + + [Test] + public void GetGroupAndIndexOfItemItemNotFound() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var result = bindable.TemplatedItems.GetGroupAndIndexOfItem (items[1], "bam"); + + Assert.That (result.Item1, Is.EqualTo (1)); + Assert.That (result.Item2, Is.EqualTo (-1)); + } + + [Test] + [Description ("Issue #2464: ANE thrown when moving items in a ListView")] + public void MovingPastRealizedWindowAndBackDoesntThrow() + { + var items = new ObservableCollection<string> (Enumerable.Range (0, 100).Select (i => i.ToString())); + + bindable.ItemsSource = items; + + bindable.TemplatedItems.GetOrCreateContent (0, items[0]); + bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + items.Move (0, 3); + Assert.That (() => items.Move (3, 2), Throws.Nothing); + + Assert.That (GetIndex (bindable.TemplatedItems[0]), Is.EqualTo (0)); + Assert.That (GetIndex (bindable.TemplatedItems[1]), Is.EqualTo (1)); + Assert.That (GetIndex (bindable.TemplatedItems[2]), Is.EqualTo (2)); + Assert.That (GetIndex (bindable.TemplatedItems[3]), Is.EqualTo (3)); + } + + [Test] + public void GetGlobalIndexOfItem () + { + var items = new ObservableCollection<string> (Enumerable.Range (0, 100).Select (i => i.ToString())); + bindable.ItemsSource = items; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem ("50"); + Assert.That (global, Is.EqualTo (50)); + } + + [Test] + public void GetGlobalIndexOfItemNotFound () + { + var items = new ObservableCollection<string> (Enumerable.Range (0, 100).Select (i => i.ToString())); + bindable.ItemsSource = items; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem ("101"); + Assert.That (global, Is.EqualTo (-1)); + } + + [Test] + public void GetGlobalIndexOfItemGrouped () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem ("baz"); + Assert.That (global, Is.EqualTo (5)); + } + + [Test] + public void GetGlobalIndexOfItemGroupedNotFound () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem ("101"); + Assert.That (global, Is.EqualTo (-1)); + } + + [Test] + public void GetGlobalIndexOfGroupItemGrouped () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "baz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem (items[1], "baz"); + Assert.That (global, Is.EqualTo (5)); + } + + [Test] + public void GetGlobalIndexOfGroupItemGroupedNotFound () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "foo", "faz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem (items[1], "bar"); + Assert.That (global, Is.EqualTo (-1)); + } + + [Test] + public void GetGlobalIndexOfGroupItemGroupedGroupNotFound () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "foo", "faz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + int global = bindable.TemplatedItems.GetGlobalIndexOfItem (new object(), "foo"); + Assert.That (global, Is.EqualTo (-1)); + } + + [Test] + public void SetupContentOnCreation() + { + var items = new ObservableCollection<string> { + "Foo", + "Bar" + }; + + bindable.ItemTemplate = new DataTemplate (typeof (TextCell)) { + Bindings = { + { TextCell.TextProperty, new Binding (".") } + } + }; + + int count = 0; + bindable.Hooked += obj => { + count++; + Assert.That (obj, Is.InstanceOf (typeof (TextCell))); + Assert.That (items, Contains.Item (obj.BindingContext)); + }; + + bindable.ItemsSource = items; + + bindable.TemplatedItems.GetOrCreateContent (0, items[0]); + bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + Assert.That (count, Is.EqualTo (2)); + } + + [Test] + public void UnhookGroupOnRemoval() + { + var inner = new ObservableCollection<string> { + "Foo", + }; + + var items = new ObservableCollection<ObservableCollection<string>> { + inner + }; + + bindable.IsGroupingEnabled = true; + bindable.GroupDisplayBinding = new Binding (".[0]"); + + bindable.ItemTemplate = new DataTemplate (typeof (TextCell)) { + Bindings = { + { TextCell.TextProperty, new Binding (".") } + } + }; + + int count = 0; + bindable.Unhooked += obj => { + if (count == 0) { + Assert.That (obj.BindingContext, Is.InstanceOf (typeof (TemplatedItemsList<ItemsView<BindableObject>, BindableObject>))); + Assert.That (((TemplatedItemsList<ItemsView<BindableObject>, BindableObject>) obj.BindingContext).ListProxy.ProxiedEnumerable, Is.SameAs (inner)); + } else { + Assert.That (obj.BindingContext, Is.SameAs (inner[0])); + } + + count++; + }; + + bindable.ItemsSource = items; + + var til = bindable.TemplatedItems.GetGroup (0); + til.GetOrCreateContent (0, inner[0]); + + Assume.That (til, Is.Not.Null); + Assume.That (til.HeaderContent, Is.Not.Null); + Assume.That (count, Is.EqualTo (0)); + + items.RemoveAt (0); + + Assert.That (count, Is.EqualTo (2)); + } + + [Test] + public void HookAndUnhookGroupOnReplace() + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { + "Foo", + } + }; + + bindable.IsGroupingEnabled = true; + bindable.GroupDisplayBinding = new Binding (".[0]"); + bindable.ItemTemplate = new DataTemplate (typeof (TextCell)) { + Bindings = { + { TextCell.TextProperty, new Binding (".") } + } + }; + + bindable.ItemsSource = items; + + var til = bindable.TemplatedItems.GetGroup (0); + til.GetOrCreateContent (0, items[0][0]); + + Assume.That (til, Is.Not.Null); + Assume.That (til.HeaderContent, Is.Not.Null); + + int hcount = 0; + bindable.Hooked += obj => { + Assert.That (obj.BindingContext, Is.InstanceOf (typeof (TemplatedItemsList<ItemsView<BindableObject>, BindableObject>))); + hcount++; + }; + + int ucount = 0; + bindable.Unhooked += obj => { + Assert.That (obj.BindingContext, + Is.InstanceOf (typeof (TemplatedItemsList<ItemsView<BindableObject>, BindableObject>)) + .Or.EqualTo ("Foo")); + + ucount++; + }; + + items[0] = new ObservableCollection<string> { "Baz" }; + + Assert.That (hcount, Is.EqualTo (1)); + Assert.That (ucount, Is.EqualTo (2)); + } + + [Test] + public void UnhookContentOnRemoval() + { + var items = new ObservableCollection<string> { + "Foo", + "Bar" + }; + + bindable.ItemTemplate = new DataTemplate (typeof (TextCell)) { + Bindings = { + { TextCell.TextProperty, new Binding (".") } + } + }; + + int count = 0; + bindable.Unhooked += obj => { + count++; + Assert.That (obj, Is.InstanceOf (typeof (TextCell))); + Assert.That (obj.BindingContext, Is.EqualTo ("Foo")); + }; + + bindable.ItemsSource = items; + + bindable.TemplatedItems.GetOrCreateContent (0, items[0]); + bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + Assume.That (count, Is.EqualTo (0)); + + items.RemoveAt (0); + + Assert.That (count, Is.EqualTo (1)); + } + + [Test] + public void HookAndUnhookContentOnReplace() + { + var items = new ObservableCollection<string> { + "Foo", + "Bar" + }; + + bindable.ItemTemplate = new DataTemplate (typeof (TextCell)) { + Bindings = { + { TextCell.TextProperty, new Binding (".") } + } + }; + + bindable.ItemsSource = items; + + bindable.TemplatedItems.GetOrCreateContent (0, items[0]); + bindable.TemplatedItems.GetOrCreateContent (1, items[1]); + + int hcount = 0; + bindable.Hooked += obj => { + hcount++; + Assert.That (obj, Is.InstanceOf (typeof (TextCell))); + Assert.That (obj.BindingContext, Is.EqualTo ("Baz")); + }; + + int ucount = 0; + bindable.Unhooked += obj => { + ucount++; + Assert.That (obj, Is.InstanceOf (typeof (TextCell))); + Assert.That (obj.BindingContext, Is.EqualTo ("Foo")); + }; + + items[0] = "Baz"; + + Assert.That (hcount, Is.EqualTo (1)); + Assert.That (ucount, Is.EqualTo (1)); + } + + [Test (Description = "If the cell exists and has an index, we still need to check if it's in the group asked for")] + public void IndexOfFailsForCellInAnotherGroup () + { + var items = new ObservableCollection<ObservableCollection<string>> { + new ObservableCollection<string> { "foo", "faz" }, + new ObservableCollection<string> { "bar", "baz" } + }; + + bindable.ItemsSource = items; + bindable.GroupShortNameBinding = new Binding ("."); + bindable.IsGroupingEnabled = true; + + var group1 = bindable.TemplatedItems.GetGroup (0); + var cell = group1[1]; + + Assume.That (group1.IndexOf (cell), Is.EqualTo (1)); + + var group2 = bindable.TemplatedItems.GetGroup (1); + + Assert.That (group2.IndexOf (cell), Is.EqualTo (-1)); + } + } +} |