mirror of
https://github.com/CommunityToolkit/dotnet.git
synced 2026-10-20 06:07:37 +08:00
Sergio Pedri
12ae36b594
Replaces usages of Assert.AreEqual, Assert.IsTrue, and similar assertions with new helper methods such as Assert.HasCount, Assert.IsEmpty, Assert.IsNull, and Assert.IsGreaterThanOrEqualTo across multiple test files. This improves test readability and consistency with updated assertion APIs.
453 lines
19 KiB
C#
453 lines
19 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
// See the LICENSE file in the project root for more information.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using CommunityToolkit.Mvvm.Collections;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
namespace CommunityToolkit.Mvvm.UnitTests.Collections;
|
|
|
|
[TestClass]
|
|
public class Test_ObservableGroupedCollectionExtensions
|
|
{
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExists_ShouldReturnFirstGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
|
|
ObservableGroup<string, int> target = groupedCollection.AddGroup("B", new[] { 10 });
|
|
|
|
_ = groupedCollection.AddGroup("B", new[] { 42 });
|
|
|
|
ObservableGroup<string, int> result = groupedCollection.FirstGroupByKey("B");
|
|
|
|
Assert.AreSame(result, target);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupDoesNotExist_ShouldThrow()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
|
|
_ = Assert.ThrowsExactly<InvalidOperationException>(() => _ = groupedCollection.FirstGroupByKey("I do not exist"));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKeyOrDefault_WhenGroupExists_ShouldReturnFirstGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
|
|
ObservableGroup<string, int> target = groupedCollection.AddGroup("B", new[] { 10 });
|
|
|
|
_ = groupedCollection.AddGroup("B", new[] { 42 });
|
|
|
|
ObservableGroup<string, int>? result = groupedCollection.FirstGroupByKeyOrDefault("B");
|
|
|
|
Assert.AreSame(result, target);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKeyOrDefault_WhenGroupDoesNotExist_ShouldReturnNull()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
|
|
ObservableGroup<string, int>? result = groupedCollection.FirstGroupByKeyOrDefault("I do not exist");
|
|
|
|
Assert.IsNull(result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExistsAndIndexInRange_ShouldReturnFirstGroupValue()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 10, 11, 12 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 42 });
|
|
|
|
int result = groupedCollection.FirstGroupByKey("B")[2];
|
|
|
|
Assert.AreEqual(12, result);
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(-1)]
|
|
[DataRow(3)]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExistsAndIndexOutOfRange_ShouldReturnThrow(int index)
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 10, 11, 12 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 42 });
|
|
|
|
_ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = groupedCollection.FirstGroupByKey("B")[index]);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_FirstGroupByKey_WhenGroupExistsAndIndexInRange_ShouldReturnValue()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 23 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 10, 11, 12 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 42 });
|
|
|
|
int result = groupedCollection.FirstGroupByKey("B")[2];
|
|
|
|
Assert.AreEqual(12, result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddGroup_WithItem_ShouldAddGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddGroup("new key", new[] { 23 });
|
|
|
|
Assert.IsNotNull(addedGroup);
|
|
Assert.AreEqual("new key", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 23 });
|
|
CollectionAssert.AreEqual(groupedCollection, new[] { addedGroup });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddGroup_WithCollection_ShouldAddGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddGroup("new key", new[] { 23, 10, 42 });
|
|
|
|
Assert.IsNotNull(addedGroup);
|
|
Assert.AreEqual("new key", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 23, 10, 42 });
|
|
CollectionAssert.AreEqual(groupedCollection, new[] { addedGroup });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddGroup_WithParamsCollection_ShouldAddGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddGroup("new key", new[] { 23, 10, 42 });
|
|
|
|
Assert.IsNotNull(addedGroup);
|
|
Assert.AreEqual("new key", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 23, 10, 42 });
|
|
CollectionAssert.AreEqual(groupedCollection, new[] { addedGroup });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_InsertGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> a = groupedCollection.InsertGroup("A", new[] { 1, 2, 3 });
|
|
ObservableGroup<string, int> d = groupedCollection.InsertGroup("D", new[] { 1, 2, 3 });
|
|
ObservableGroup<string, int> e = groupedCollection.InsertGroup("E", new[] { 1, 2, 3 });
|
|
ObservableGroup<string, int> b = groupedCollection.InsertGroup("B", new[] { 1, 2, 3 });
|
|
ObservableGroup<string, int> z = groupedCollection.InsertGroup("Z", new[] { 1, 2, 3 });
|
|
ObservableGroup<string, int> c = groupedCollection.InsertGroup("C", new[] { 1, 2, 3 });
|
|
|
|
CollectionAssert.AllItemsAreNotNull(new[] { a, d, e, b, z, c });
|
|
CollectionAssert.AreEqual(new[] { a, b, c, d, e, z }, groupedCollection);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_InsertGroup_WithGrouping()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> a = groupedCollection.InsertGroup(new IntGroup("A", new[] { 1, 2, 3 }));
|
|
ObservableGroup<string, int> d = groupedCollection.InsertGroup(new IntGroup("D", new[] { 1, 2, 3 }));
|
|
ObservableGroup<string, int> e = groupedCollection.InsertGroup(new IntGroup("E", new[] { 1, 2, 3 }));
|
|
ObservableGroup<string, int> b = groupedCollection.InsertGroup(new IntGroup("B", new[] { 1, 2, 3 }));
|
|
ObservableGroup<string, int> z = groupedCollection.InsertGroup(new IntGroup("Z", new[] { 1, 2, 3 }));
|
|
ObservableGroup<string, int> c = groupedCollection.InsertGroup(new IntGroup("C", new[] { 1, 2, 3 }));
|
|
|
|
CollectionAssert.AllItemsAreNotNull(new[] { a, d, e, b, z, c });
|
|
CollectionAssert.AreEqual(new[] { a, b, c, d, e, z }, groupedCollection);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddItem_WhenTargetGroupDoesNotExists_ShouldCreateAndAddNewGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddItem("new key", 23);
|
|
|
|
Assert.IsNotNull(addedGroup);
|
|
Assert.AreEqual("new key", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 23 });
|
|
CollectionAssert.AreEqual(groupedCollection, new[] { addedGroup });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddItem_WhenSingleTargetGroupAlreadyExists_ShouldAddItemToExistingGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
|
|
ObservableGroup<string, int> targetGroup = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
_ = groupedCollection.AddGroup("C", new[] { 7, 8 });
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddItem("B", 23);
|
|
|
|
Assert.AreSame(addedGroup, targetGroup);
|
|
Assert.AreEqual("B", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 4, 5, 6, 23 });
|
|
|
|
Assert.HasCount(3, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 4, 5, 6, 23 });
|
|
|
|
Assert.AreEqual("C", groupedCollection[2].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[2], new[] { 7, 8 });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_AddItem_WhenSeveralTargetGroupsAlreadyExist_ShouldAddItemToFirstExistingGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
|
|
ObservableGroup<string, int> targetGroup = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
_ = groupedCollection.AddGroup("B", new[] { 7, 8, 9 });
|
|
_ = groupedCollection.AddGroup("C", new[] { 10, 11 });
|
|
|
|
ObservableGroup<string, int> addedGroup = groupedCollection.AddItem("B", 23);
|
|
|
|
Assert.AreSame(addedGroup, targetGroup);
|
|
Assert.AreEqual("B", addedGroup.Key);
|
|
CollectionAssert.AreEqual(addedGroup, new[] { 4, 5, 6, 23 });
|
|
|
|
Assert.HasCount(4, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 4, 5, 6, 23 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[2].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[2], new[] { 7, 8, 9 });
|
|
|
|
Assert.AreEqual("C", groupedCollection[3].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[3], new[] { 10, 11 });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_InsertItem()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> group1 = groupedCollection.InsertItem("A", 1);
|
|
ObservableGroup<string, int> group2 = groupedCollection.InsertItem("A", 2);
|
|
ObservableGroup<string, int> group6 = groupedCollection.InsertItem("A", 6);
|
|
ObservableGroup<string, int> group4 = groupedCollection.InsertItem("A", 4);
|
|
ObservableGroup<string, int> group3 = groupedCollection.InsertItem("A", 3);
|
|
ObservableGroup<string, int> group99 = groupedCollection.InsertItem("A", 99);
|
|
ObservableGroup<string, int> group8 = groupedCollection.InsertItem("B", 8);
|
|
ObservableGroup<string, int> group7 = groupedCollection.InsertItem("B", 7);
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
CollectionAssert.AllItemsAreNotNull(new[] { group1, group2, group6, group4, group3, group99, group8, group7 });
|
|
|
|
Assert.AreSame(group1, group2);
|
|
Assert.AreSame(group1, group6);
|
|
Assert.AreSame(group1, group4);
|
|
Assert.AreSame(group1, group3);
|
|
Assert.AreSame(group1, group2);
|
|
Assert.AreSame(group1, group99);
|
|
Assert.AreNotSame(group1, group8);
|
|
Assert.AreSame(group8, group7);
|
|
|
|
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 6, 99 }, group1);
|
|
CollectionAssert.AreEqual(new[] { 7, 8 }, group8);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_InsertItem_WithComparer()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
ObservableGroup<string, int> group1 = groupedCollection.InsertItem("A", Comparer<string>.Default, 1, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group2 = groupedCollection.InsertItem("A", Comparer<string>.Default, 2, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group6 = groupedCollection.InsertItem("A", Comparer<string>.Default, 6, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group4 = groupedCollection.InsertItem("A", Comparer<string>.Default, 4, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group3 = groupedCollection.InsertItem("A", Comparer<string>.Default, 3, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group99 = groupedCollection.InsertItem("A", Comparer<string>.Default, 99, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group8 = groupedCollection.InsertItem("B", Comparer<string>.Default, 8, Comparer<int>.Default);
|
|
ObservableGroup<string, int> group7 = groupedCollection.InsertItem("B", Comparer<string>.Default, 7, Comparer<int>.Default);
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
CollectionAssert.AllItemsAreNotNull(new[] { group1, group2, group6, group4, group3, group99, group8, group7 });
|
|
|
|
Assert.AreSame(group1, group2);
|
|
Assert.AreSame(group1, group6);
|
|
Assert.AreSame(group1, group4);
|
|
Assert.AreSame(group1, group3);
|
|
Assert.AreSame(group1, group2);
|
|
Assert.AreSame(group1, group99);
|
|
Assert.AreNotSame(group1, group8);
|
|
Assert.AreSame(group8, group7);
|
|
|
|
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 6, 99 }, group1);
|
|
CollectionAssert.AreEqual(new[] { 7, 8 }, group8);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveGroup_WhenGroupDoesNotExists_ShouldDoNothing()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
|
|
groupedCollection.RemoveGroup("I do not exist");
|
|
|
|
Assert.HasCount(1, groupedCollection);
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveGroup_WhenSingleGroupExists_ShouldRemoveGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
groupedCollection.RemoveGroup("B");
|
|
|
|
Assert.HasCount(1, groupedCollection);
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveGroup_WhenSeveralGroupsExist_ShouldRemoveFirstGroup()
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 7, 8 });
|
|
|
|
groupedCollection.RemoveGroup("B");
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 7, 8 });
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(true)]
|
|
[DataRow(false)]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveItem_WhenGroupDoesNotExist_ShouldDoNothing(bool removeGroupIfEmpty)
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
groupedCollection.RemoveItem("I do not exist", 8, removeGroupIfEmpty);
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 4, 5, 6 });
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(true)]
|
|
[DataRow(false)]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveItem_WhenGroupExistsAndItemDoesNotExist_ShouldDoNothing(bool removeGroupIfEmpty)
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
groupedCollection.RemoveItem("B", 8, removeGroupIfEmpty);
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 4, 5, 6 });
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(true)]
|
|
[DataRow(false)]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveItem_WhenGroupAndItemExist_ShouldRemoveItemFromGroup(bool removeGroupIfEmpty)
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4, 5, 6 });
|
|
|
|
groupedCollection.RemoveItem("B", 5, removeGroupIfEmpty);
|
|
|
|
Assert.HasCount(2, groupedCollection);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[1], new[] { 4, 6 });
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(true, true)]
|
|
[DataRow(false, false)]
|
|
public void Test_ObservableGroupedCollectionExtensions_RemoveItem_WhenRemovingLastItem_ShouldRemoveGroupIfRequired(bool removeGroupIfEmpty, bool expectGroupRemoved)
|
|
{
|
|
ObservableGroupedCollection<string, int> groupedCollection = new();
|
|
|
|
_ = groupedCollection.AddGroup("A", new[] { 1, 2, 3 });
|
|
_ = groupedCollection.AddGroup("B", new[] { 4 });
|
|
|
|
groupedCollection.RemoveItem("B", 4, removeGroupIfEmpty);
|
|
|
|
Assert.AreEqual(groupedCollection.Count, expectGroupRemoved ? 1 : 2);
|
|
|
|
Assert.AreEqual("A", groupedCollection[0].Key);
|
|
CollectionAssert.AreEqual(groupedCollection[0], new[] { 1, 2, 3 });
|
|
|
|
if (!expectGroupRemoved)
|
|
{
|
|
Assert.AreEqual("B", groupedCollection[1].Key);
|
|
Assert.IsEmpty(groupedCollection[1]);
|
|
}
|
|
}
|
|
}
|