public void ElementAtOrDefault_WhenGroupExistsAndIndexOutOfRange_ShouldReturnDefaultValue(int index)
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 23);
groupedCollection.AddGroup("B", 10, 11, 12);
groupedCollection.AddGroup("B", 42);
var result = groupedCollection.ElementAtOrDefault("B", index);
result.Should().Be(0);
}
public void RemoveGroup_WhenGroupDoesNotExists_ShouldDoNothing()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 1, 2, 3);
groupedCollection.RemoveGroup("I do not exist");
groupedCollection.Should().ContainSingle();
groupedCollection.ElementAt(0).Key.Should().Be("A");
groupedCollection.ElementAt(0).Should().HaveCount(3);
groupedCollection.ElementAt(0).Should().ContainInOrder(1, 2, 3);
}
public void FirstOrDefault_WhenGroupExists_ShouldReturnFirstGroup()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 23);
var target = groupedCollection.AddGroup("B", 10);
groupedCollection.AddGroup("B", 42);
var result = groupedCollection.FirstOrDefault("B");
result.Should().BeSameAs(target);
}
public void AddItem_WhenTargetGroupDoesNotExists_ShouldCreateAndAddNewGroup()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
var addedGroup = groupedCollection.AddItem("new key", 23);
addedGroup.Should().NotBeNull();
addedGroup.Key.Should().Be("new key");
addedGroup.Should().ContainSingle();
addedGroup.Should().ContainInOrder(23);
groupedCollection.Should().ContainSingle();
groupedCollection.Should().HaveElementAt(0, addedGroup);
}
public void AddGroup_WithParamsCollection_ShouldAddGroup()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
var addedGroup = groupedCollection.AddGroup("new key", 23, 10, 42);
addedGroup.Should().NotBeNull();
addedGroup.Key.Should().Be("new key");
addedGroup.Should().HaveCount(3);
addedGroup.Should().ContainInOrder(23, 10, 42);
groupedCollection.Should().ContainSingle();
groupedCollection.Should().HaveElementAt(0, addedGroup);
}
public void RemoveGroup_WhenSingleGroupExists_ShouldRemoveGroup()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 1, 2, 3);
groupedCollection.AddGroup("B", 4, 5, 6);
groupedCollection.RemoveGroup("B");
groupedCollection.Should().ContainSingle();
groupedCollection.ElementAt(0).Key.Should().Be("A");
groupedCollection.ElementAt(0).Should().HaveCount(3);
groupedCollection.ElementAt(0).Should().ContainInOrder(1, 2, 3);
}
public void Ctor_WithGroups_ShouldHaveExpectedValues()
{
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", new[] { 1, 3, 5 }),
new IntGroup("B", new[] { 2, 4, 6 }),
};
var groupCollection = new ObservableGroupedCollection <string, int>(groups);
groupCollection.Should().HaveCount(2);
groupCollection.ElementAt(0).Key.Should().Be("A");
groupCollection.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithStrictOrdering());
groupCollection.ElementAt(1).Key.Should().Be("B");
groupCollection.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithStrictOrdering());
}
public void Ctor_WithObservableGroupedCollection_ShoudInitializeObject()
{
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", new[] { 1, 3, 5 }),
new IntGroup("B", new[] { 2, 4, 6 }),
};
var source = new ObservableGroupedCollection <string, int>(groups);
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
readOnlyGroup.Should().HaveCount(2);
readOnlyGroup.Count.Should().Be(2);
readOnlyGroup.ElementAt(0).Key.Should().Be("A");
readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(new[] { 1, 3, 5 }, o => o.WithoutStrictOrdering());
readOnlyGroup.ElementAt(1).Key.Should().Be("B");
readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(new[] { 2, 4, 6 }, o => o.WithoutStrictOrdering());
}
public void IListImplementation_Contains_ShoudReturnExpectedValue(int groupIndex, bool expectedResult)
{
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", new[] { 1, 3, 5 }),
new IntGroup("B", new[] { 2, 4, 6 }),
};
var source = new ObservableGroupedCollection <string, int>(groups);
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
var list = (IList)readOnlyGroup;
var groupToSearch = groupIndex >= 0 ? list[groupIndex] : null;
var result = list.Contains(groupToSearch);
result.Should().Be(expectedResult);
}
public void IListImplementation_IndexOf_ShoudReturnExpectedValue(int groupIndex)
{
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", new[] { 1, 3, 5 }),
new IntGroup("B", new[] { 2, 4, 6 }),
new IntGroup("C", new[] { 7, 8, 9 }),
};
var source = new ObservableGroupedCollection <string, int>(groups);
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
var list = (IList)readOnlyGroup;
var groupToSearch = groupIndex >= 0 ? list[groupIndex] : null;
var index = list.IndexOf(groupToSearch);
index.Should().Be(groupIndex);
}
public void RemoveItem_WhenGroupAndItemExist_ShouldRemoveItemFromGroup(bool removeGroupIfEmpty)
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 1, 2, 3);
groupedCollection.AddGroup("B", 4, 5, 6);
groupedCollection.RemoveItem("B", 5, removeGroupIfEmpty);
groupedCollection.Should().HaveCount(2);
groupedCollection.ElementAt(0).Key.Should().Be("A");
groupedCollection.ElementAt(0).Should().HaveCount(3);
groupedCollection.ElementAt(0).Should().ContainInOrder(1, 2, 3);
groupedCollection.ElementAt(1).Key.Should().Be("B");
groupedCollection.ElementAt(1).Should().HaveCount(2);
groupedCollection.ElementAt(1).Should().ContainInOrder(4, 6);
}
public void RemoveGroup_WhenSeveralGroupsExist_ShouldRemoveFirstGroup()
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 1, 2, 3);
groupedCollection.AddGroup("B", 4, 5, 6);
groupedCollection.AddGroup("B", 7, 8);
groupedCollection.RemoveGroup("B");
groupedCollection.Should().HaveCount(2);
groupedCollection.ElementAt(0).Key.Should().Be("A");
groupedCollection.ElementAt(0).Should().HaveCount(3);
groupedCollection.ElementAt(0).Should().ContainInOrder(1, 2, 3);
groupedCollection.ElementAt(1).Key.Should().Be("B");
groupedCollection.ElementAt(1).Should().HaveCount(2);
groupedCollection.ElementAt(1).Should().ContainInOrder(7, 8);
}
public ObservableGroupPage()
{
var contacts = new[]
{
new Person {
Name = "Staff"
},
new Person {
Name = "Swan"
},
new Person {
Name = "Orchid"
},
new Person {
Name = "Flame"
},
new Person {
Name = "Arrow"
},
new Person {
Name = "Tempest"
},
new Person {
Name = "Pearl"
},
new Person {
Name = "Hydra"
},
new Person {
Name = "Lamp Post"
},
new Person {
Name = "Looking Glass"
},
};
var grouped = contacts.GroupBy(GetGroupName).OrderBy(g => g.Key);
_contactsSource = new ObservableGroupedCollection <string, Person>(grouped);
Contacts = new ReadOnlyObservableGroupedCollection <string, Person>(_contactsSource);
InitializeComponent();
}
public void RemoveItem_WhenRemovingLastItem_ShouldRemoveGroupIfRequired(bool removeGroupIfEmpty, bool expectGroupRemoved)
{
var groupedCollection = new ObservableGroupedCollection <string, int>();
groupedCollection.AddGroup("A", 1, 2, 3);
groupedCollection.AddGroup("B", 4);
groupedCollection.RemoveItem("B", 4, removeGroupIfEmpty);
groupedCollection.Should().HaveCount(expectGroupRemoved ? 1 : 2);
groupedCollection.ElementAt(0).Key.Should().Be("A");
groupedCollection.ElementAt(0).Should().HaveCount(3);
groupedCollection.ElementAt(0).Should().ContainInOrder(1, 2, 3);
if (!expectGroupRemoved)
{
groupedCollection.ElementAt(1).Key.Should().Be("B");
groupedCollection.ElementAt(1).Should().BeEmpty();
}
}
public void IListImplementation_MutableMethods_ShoudThrow()
{
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", new[] { 1, 3, 5 }),
new IntGroup("B", new[] { 2, 4, 6 }),
};
var source = new ObservableGroupedCollection <string, int>(groups);
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
var list = (IList)readOnlyGroup;
var testGroup = new ReadOnlyObservableGroup <string, int>("test", new ObservableCollection <int>());
Action add = () => list.Add(testGroup);
add.Should().Throw <NotSupportedException>();
Action clear = () => list.Clear();
clear.Should().Throw <NotSupportedException>();
Action insert = () => list.Insert(2, testGroup);
insert.Should().Throw <NotSupportedException>();
Action remove = () => list.Remove(testGroup);
remove.Should().Throw <NotSupportedException>();
Action removeAt = () => list.RemoveAt(2);
removeAt.Should().Throw <NotSupportedException>();
Action set = () => list[2] = testGroup;
set.Should().Throw <NotSupportedException>();
var array = new object[5];
Action copyTo = () => list.CopyTo(array, 0);
copyTo.Should().NotThrow();
}
public void ReplaceGroupInSource_ShoudReplaceGroup()
{
NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
var collectionChangedEventsCount = 0;
var isCountPropertyChangedEventRaised = false;
var aItemsList = new[] { 1, 2, 3 };
var bItemsList = new[] { 2, 4, 6 };
var cItemsList = new[] { 7, 8, 9 };
var groups = new List <IGrouping <string, int> >
{
new IntGroup("A", aItemsList),
new IntGroup("B", bItemsList),
};
var source = new ObservableGroupedCollection <string, int>(groups);
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
{
collectionChangedEventArgs = e;
collectionChangedEventsCount++;
};
((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
source[0] = new ObservableGroup <string, int>("C", cItemsList);
readOnlyGroup.Should().HaveCount(2);
readOnlyGroup.Count.Should().Be(2);
readOnlyGroup.ElementAt(0).Key.Should().Be("C");
readOnlyGroup.ElementAt(0).Should().BeEquivalentTo(cItemsList, o => o.WithoutStrictOrdering());
readOnlyGroup.ElementAt(1).Key.Should().Be("B");
readOnlyGroup.ElementAt(1).Should().BeEquivalentTo(bItemsList, o => o.WithoutStrictOrdering());
isCountPropertyChangedEventRaised.Should().BeFalse();
collectionChangedEventArgs.Should().NotBeNull();
collectionChangedEventsCount.Should().Be(1);
IsReplaceEventValid(collectionChangedEventArgs, aItemsList, cItemsList).Should().BeTrue();
}
public void AddGroupInSource_ShouldAddGroup(int sourceInitialItemsCount, int expectedInsertionIndex)
{
NotifyCollectionChangedEventArgs collectionChangedEventArgs = null;
var collectionChangedEventsCount = 0;
var isCountPropertyChangedEventRaised = false;
var itemsList = new[] { 1, 2, 3 };
var source = new ObservableGroupedCollection <string, int>();
for (var i = 0; i < sourceInitialItemsCount; i++)
{
source.Add(new ObservableGroup <string, int>($"group {i}", Enumerable.Empty <int>()));
}
var readOnlyGroup = new ReadOnlyObservableGroupedCollection <string, int>(source);
((INotifyCollectionChanged)readOnlyGroup).CollectionChanged += (s, e) =>
{
collectionChangedEventArgs = e;
collectionChangedEventsCount++;
};
((INotifyPropertyChanged)readOnlyGroup).PropertyChanged += (s, e) => isCountPropertyChangedEventRaised = isCountPropertyChangedEventRaised || e.PropertyName == nameof(readOnlyGroup.Count);
source.Add(new ObservableGroup <string, int>("Add", itemsList));
var expectedReadOnlyGroupCount = sourceInitialItemsCount + 1;
readOnlyGroup.Should().HaveCount(expectedReadOnlyGroupCount);
readOnlyGroup.Count.Should().Be(expectedReadOnlyGroupCount);
readOnlyGroup.Last().Key.Should().Be("Add");
readOnlyGroup.Last().Should().BeEquivalentTo(itemsList, o => o.WithoutStrictOrdering());
isCountPropertyChangedEventRaised.Should().BeTrue();
collectionChangedEventArgs.Should().NotBeNull();
collectionChangedEventsCount.Should().Be(1);
IsAddEventValid(collectionChangedEventArgs, itemsList, expectedInsertionIndex).Should().BeTrue();
}
public void Ctor_ShouldHaveExpectedValues()
{
var groupCollection = new ObservableGroupedCollection <string, int>();
groupCollection.Should().BeEmpty();
}
