629 lines
18 KiB
C#
629 lines
18 KiB
C#
using Common.ExpandFun;
|
|
|
|
namespace Common.Test;
|
|
|
|
/// <summary>
|
|
/// CollectionExpand 集合扩展测试
|
|
/// 展示分页、树形结构、批处理等集合操作功能
|
|
/// </summary>
|
|
[TestClass]
|
|
public class CollectionExpandTests
|
|
{
|
|
#region 测试数据类
|
|
|
|
private class TestItem
|
|
{
|
|
public int Id { get; set; }
|
|
public string Name { get; set; } = "";
|
|
public int? ParentId { get; set; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 分页测试
|
|
|
|
[TestMethod]
|
|
public void ToPagedResult_BasicPaging_ReturnsCorrectPage()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 100).ToList();
|
|
|
|
// Act
|
|
var page1 = items.ToPagedResult(1, 10);
|
|
var page2 = items.ToPagedResult(2, 10);
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, page1.PageIndex);
|
|
Assert.AreEqual(10, page1.PageSize);
|
|
Assert.AreEqual(100, page1.TotalCount);
|
|
Assert.AreEqual(10, page1.TotalPages);
|
|
Assert.AreEqual(10, page1.Items.Count);
|
|
Assert.AreEqual(1, page1.Items.First());
|
|
Assert.AreEqual(10, page1.Items.Last());
|
|
|
|
Assert.AreEqual(11, page2.Items.First());
|
|
Assert.AreEqual(20, page2.Items.Last());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToPagedResult_LastPage_ReturnsPartialPage()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 25).ToList();
|
|
|
|
// Act
|
|
var lastPage = items.ToPagedResult(3, 10);
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, lastPage.PageIndex);
|
|
Assert.AreEqual(5, lastPage.Items.Count); // 最后一页只有 5 个元素
|
|
Assert.AreEqual(21, lastPage.Items.First());
|
|
Assert.AreEqual(25, lastPage.Items.Last());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToPagedResult_InvalidPageIndex_ClampsToValidRange()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 50).ToList();
|
|
|
|
// Act
|
|
var zeroPage = items.ToPagedResult(0, 10); // 应该被修正为第 1 页
|
|
var negativePage = items.ToPagedResult(-1, 10); // 应该被修正为第 1 页
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, zeroPage.PageIndex);
|
|
Assert.AreEqual(1, negativePage.PageIndex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void PagedResult_Navigation_PropertiesWorkCorrectly()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 50).ToList();
|
|
|
|
// Act
|
|
var firstPage = items.ToPagedResult(1, 10);
|
|
var middlePage = items.ToPagedResult(3, 10);
|
|
var lastPage = items.ToPagedResult(5, 10);
|
|
|
|
// Assert
|
|
Assert.IsFalse(firstPage.HasPreviousPage);
|
|
Assert.IsTrue(firstPage.HasNextPage);
|
|
|
|
Assert.IsTrue(middlePage.HasPreviousPage);
|
|
Assert.IsTrue(middlePage.HasNextPage);
|
|
|
|
Assert.IsTrue(lastPage.HasPreviousPage);
|
|
Assert.IsFalse(lastPage.HasNextPage);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 树形结构测试
|
|
|
|
[TestMethod]
|
|
public void ToTree_FlatListToTree_BuildsCorrectHierarchy()
|
|
{
|
|
// Arrange: 创建平铺的列表
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "根节点1", ParentId = null },
|
|
new() { Id = 2, Name = "根节点2", ParentId = null },
|
|
new() { Id = 3, Name = "子节点1-1", ParentId = 1 },
|
|
new() { Id = 4, Name = "子节点1-2", ParentId = 1 },
|
|
new() { Id = 5, Name = "子节点2-1", ParentId = 2 },
|
|
new() { Id = 6, Name = "孙节点1-1-1", ParentId = 3 }
|
|
};
|
|
|
|
// Act
|
|
var tree = items.ToTree(
|
|
x => x.Id,
|
|
x => x.ParentId,
|
|
null
|
|
);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, tree.Count); // 两个根节点
|
|
Assert.AreEqual("根节点1", tree[0].Data.Name);
|
|
Assert.AreEqual(2, tree[0].Children.Count); // 根节点1 有两个子节点
|
|
Assert.AreEqual("子节点1-1", tree[0].Children[0].Data.Name);
|
|
Assert.AreEqual(1, tree[0].Children[0].Children.Count); // 子节点1-1 有一个孙节点
|
|
Assert.AreEqual("孙节点1-1-1", tree[0].Children[0].Children[0].Data.Name);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToTree_BuildsCorrectLevels()
|
|
{
|
|
// Arrange
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "根", ParentId = null },
|
|
new() { Id = 2, Name = "子", ParentId = 1 },
|
|
new() { Id = 3, Name = "孙", ParentId = 2 }
|
|
};
|
|
|
|
// Act
|
|
var tree = items.ToTree(x => x.Id, x => x.ParentId);
|
|
|
|
// Assert
|
|
Assert.AreEqual(0, tree[0].Level); // 根节点 Level = 0
|
|
Assert.AreEqual(1, tree[0].Children[0].Level); // 子节点 Level = 1
|
|
Assert.AreEqual(2, tree[0].Children[0].Children[0].Level); // 孙节点 Level = 2
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToFlatList_TreeToFlatList_PreservesAllNodes()
|
|
{
|
|
// Arrange
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "根", ParentId = null },
|
|
new() { Id = 2, Name = "子1", ParentId = 1 },
|
|
new() { Id = 3, Name = "子2", ParentId = 1 },
|
|
new() { Id = 4, Name = "孙", ParentId = 2 }
|
|
};
|
|
|
|
var tree = items.ToTree(x => x.Id, x => x.ParentId);
|
|
|
|
// Act
|
|
var flatList = tree.ToFlatList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(4, flatList.Count);
|
|
Assert.AreEqual("根", flatList[0].Name);
|
|
Assert.AreEqual("子1", flatList[1].Name);
|
|
Assert.AreEqual("孙", flatList[2].Name); // 深度优先遍历
|
|
Assert.AreEqual("子2", flatList[3].Name);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TraverseTree_ExecutesActionForAllNodes()
|
|
{
|
|
// Arrange
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "A", ParentId = null },
|
|
new() { Id = 2, Name = "B", ParentId = 1 },
|
|
new() { Id = 3, Name = "C", ParentId = 1 }
|
|
};
|
|
|
|
var tree = items.ToTree(x => x.Id, x => x.ParentId);
|
|
var visitedNames = new List<string>();
|
|
|
|
// Act
|
|
tree.TraverseTree(node => visitedNames.Add(node.Data.Name));
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, visitedNames.Count);
|
|
CollectionAssert.Contains(visitedNames, "A");
|
|
CollectionAssert.Contains(visitedNames, "B");
|
|
CollectionAssert.Contains(visitedNames, "C");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 批处理测试
|
|
|
|
[TestMethod]
|
|
public void Batch_DividesIntoCorrectBatches()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 10).ToList();
|
|
|
|
// Act
|
|
var batches = items.Batch(3).ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(4, batches.Count); // 10 个元素，每批 3 个，共 4 批
|
|
Assert.AreEqual(3, batches[0].Count());
|
|
Assert.AreEqual(3, batches[1].Count());
|
|
Assert.AreEqual(3, batches[2].Count());
|
|
Assert.AreEqual(1, batches[3].Count()); // 最后一批只有 1 个
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Batch_EmptyCollection_ReturnsEmpty()
|
|
{
|
|
// Arrange
|
|
var items = new List<int>();
|
|
|
|
// Act
|
|
var batches = items.Batch(5).ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(0, batches.Count);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ForEachBatch_ExecutesActionForEachBatch()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 25).ToList();
|
|
var processedBatches = new List<int>();
|
|
|
|
// Act
|
|
items.ForEachBatch(10, batch => { processedBatches.Add(batch.Count()); });
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, processedBatches.Count);
|
|
Assert.AreEqual(10, processedBatches[0]);
|
|
Assert.AreEqual(10, processedBatches[1]);
|
|
Assert.AreEqual(5, processedBatches[2]);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 空集合安全操作测试
|
|
|
|
[TestMethod]
|
|
public void OrEmpty_NullCollection_ReturnsEmptyCollection()
|
|
{
|
|
// Arrange
|
|
List<int>? nullList = null;
|
|
|
|
// Act
|
|
var result = nullList.OrEmpty();
|
|
|
|
// Assert
|
|
Assert.IsNotNull(result);
|
|
Assert.AreEqual(0, result.Count());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void OrDefault_EmptyCollection_ReturnsDefaultValue()
|
|
{
|
|
// Arrange
|
|
var emptyList = new List<int>();
|
|
var defaultList = new List<int> { 1, 2, 3 };
|
|
|
|
// Act
|
|
var result = emptyList.OrDefault(defaultList);
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, result.Count());
|
|
CollectionAssert.AreEqual(defaultList, result.ToList());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IsNullOrEmpty_VariousInputs_ReturnsCorrectResult()
|
|
{
|
|
// Arrange
|
|
List<int>? nullList = null;
|
|
var emptyList = new List<int>();
|
|
var nonEmptyList = new List<int> { 1 };
|
|
|
|
// Act & Assert
|
|
Assert.IsTrue(nullList.IsNullOrEmpty());
|
|
Assert.IsTrue(emptyList.IsNullOrEmpty());
|
|
Assert.IsFalse(nonEmptyList.IsNullOrEmpty());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void HasItems_VariousInputs_ReturnsCorrectResult()
|
|
{
|
|
// Arrange
|
|
List<int>? nullList = null;
|
|
var emptyList = new List<int>();
|
|
var nonEmptyList = new List<int> { 1 };
|
|
|
|
// Act & Assert
|
|
Assert.IsFalse(nullList.HasItems());
|
|
Assert.IsFalse(emptyList.HasItems());
|
|
Assert.IsTrue(nonEmptyList.HasItems());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DistinctBy 测试
|
|
|
|
[TestMethod]
|
|
public void DistinctBy_RemovesDuplicatesByKey()
|
|
{
|
|
// Arrange
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "A" },
|
|
new() { Id = 2, Name = "B" },
|
|
new() { Id = 3, Name = "A" }, // 重复的 Name
|
|
new() { Id = 4, Name = "C" }
|
|
};
|
|
|
|
// Act (.NET 6+ 内置 DistinctBy)
|
|
var distinct = items.DistinctBy(x => x.Name).ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, distinct.Count);
|
|
Assert.AreEqual(1, distinct[0].Id); // 保留第一个 "A"
|
|
Assert.AreEqual(2, distinct[1].Id);
|
|
Assert.AreEqual(4, distinct[2].Id);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 其他实用扩展测试
|
|
|
|
[TestMethod]
|
|
public void ForEach_ExecutesActionForAllElements()
|
|
{
|
|
// Arrange
|
|
var items = new List<int> { 1, 2, 3 };
|
|
var sum = 0;
|
|
|
|
// Act
|
|
items.ForEach(x => sum += x);
|
|
|
|
// Assert
|
|
Assert.AreEqual(6, sum);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ForEach_WithIndex_ProvidesCorrectIndex()
|
|
{
|
|
// Arrange
|
|
var items = new List<string> { "A", "B", "C" };
|
|
var results = new List<string>();
|
|
|
|
// Act
|
|
items.ForEach((item, index) => results.Add($"{index}:{item}"));
|
|
|
|
// Assert
|
|
CollectionAssert.AreEqual(new[] { "0:A", "1:B", "2:C" }, results);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void JoinString_ConcatenatesWithSeparator()
|
|
{
|
|
// Arrange
|
|
var items = new[] { "apple", "banana", "cherry" };
|
|
|
|
// Act
|
|
var result = items.JoinString(", ");
|
|
|
|
// Assert
|
|
Assert.AreEqual("apple, banana, cherry", result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Shuffle_ChangesOrder()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 100).ToList();
|
|
var original = items.ToList();
|
|
|
|
// Act
|
|
var shuffled = items.Shuffle().ToList();
|
|
|
|
// Assert: 打乱后的顺序应该不同（理论上有极小概率相同）
|
|
Assert.AreEqual(original.Count, shuffled.Count);
|
|
// 检查是否至少有一些元素位置变化
|
|
var differentPositions = original.Where((item, index) => shuffled[index] != item).Count();
|
|
Assert.IsTrue(differentPositions > 10); // 至少 10% 的元素位置不同
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TakeRandom_ReturnsSpecifiedCount()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 100).ToList();
|
|
|
|
// Act
|
|
var random10 = items.TakeRandom(10).ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(10, random10.Count);
|
|
Assert.IsTrue(random10.All(x => items.Contains(x)));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Split_DividesIntoParts()
|
|
{
|
|
// Arrange
|
|
var items = Enumerable.Range(1, 10).ToList();
|
|
|
|
// Act
|
|
var parts = items.Split(3).ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, parts.Count);
|
|
Assert.AreEqual(4, parts[0].Count()); // 10 / 3 = 向上取整 4
|
|
Assert.AreEqual(4, parts[1].Count());
|
|
Assert.AreEqual(2, parts[2].Count());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void AllUnique_ChecksUniqueness()
|
|
{
|
|
// Arrange
|
|
var uniqueList = new[] { 1, 2, 3, 4 };
|
|
var duplicateList = new[] { 1, 2, 2, 3 };
|
|
|
|
// Act & Assert
|
|
Assert.IsTrue(uniqueList.AllUnique());
|
|
Assert.IsFalse(duplicateList.AllUnique());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void HasDuplicates_DetectsDuplicates()
|
|
{
|
|
// Arrange
|
|
var uniqueList = new[] { 1, 2, 3, 4 };
|
|
var duplicateList = new[] { 1, 2, 2, 3 };
|
|
|
|
// Act & Assert
|
|
Assert.IsFalse(uniqueList.HasDuplicates());
|
|
Assert.IsTrue(duplicateList.HasDuplicates());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetDuplicates_ReturnsOnlyDuplicates()
|
|
{
|
|
// Arrange
|
|
var items = new[] { 1, 2, 2, 3, 3, 3, 4 };
|
|
|
|
// Act
|
|
var duplicates = items.GetDuplicates().ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, duplicates.Count);
|
|
CollectionAssert.Contains(duplicates, 2);
|
|
CollectionAssert.Contains(duplicates, 3);
|
|
CollectionAssert.DoesNotContain(duplicates, 1);
|
|
CollectionAssert.DoesNotContain(duplicates, 4);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Interleave_MergesAlternately()
|
|
{
|
|
// Arrange
|
|
var first = new[] { 1, 3, 5 };
|
|
var second = new[] { 2, 4, 6 };
|
|
|
|
// Act
|
|
var result = first.Interleave(second).ToList();
|
|
|
|
// Assert
|
|
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5, 6 }, result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Interleave_DifferentLengths_MergesCorrectly()
|
|
{
|
|
// Arrange
|
|
var first = new[] { 1, 3 };
|
|
var second = new[] { 2, 4, 6, 8 };
|
|
|
|
// Act
|
|
var result = first.Interleave(second).ToList();
|
|
|
|
// Assert
|
|
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 6, 8 }, result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void WhereNotNull_FiltersNullValues()
|
|
{
|
|
// Arrange
|
|
var items = new List<string?> { "A", null, "B", null, "C" };
|
|
|
|
// Act
|
|
var result = items.WhereNotNull().ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, result.Count);
|
|
CollectionAssert.AreEqual(new[] { "A", "B", "C" }, result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToDictionaryList_GroupsCorrectly()
|
|
{
|
|
// Arrange
|
|
var items = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "A", ParentId = 1 },
|
|
new() { Id = 2, Name = "B", ParentId = 1 },
|
|
new() { Id = 3, Name = "C", ParentId = 2 },
|
|
new() { Id = 4, Name = "D", ParentId = 2 }
|
|
};
|
|
|
|
// Act
|
|
var grouped = items.ToDictionaryList(
|
|
x => x.ParentId!.Value,
|
|
x => x.Name
|
|
);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, grouped.Count);
|
|
Assert.AreEqual(2, grouped[1].Count);
|
|
CollectionAssert.Contains(grouped[1], "A");
|
|
CollectionAssert.Contains(grouped[1], "B");
|
|
Assert.AreEqual(2, grouped[2].Count);
|
|
CollectionAssert.Contains(grouped[2], "C");
|
|
CollectionAssert.Contains(grouped[2], "D");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 实际应用场景测试
|
|
|
|
[TestMethod]
|
|
public void Scenario_PaginationWithSearch()
|
|
{
|
|
// Arrange: 模拟产品列表搜索和分页
|
|
var products = Enumerable.Range(1, 100)
|
|
.Select(i => new { Id = i, Name = $"Product {i}", Price = i * 10 })
|
|
.ToList();
|
|
|
|
// Act: 搜索价格大于 500 的产品，并分页
|
|
var searchResults = products
|
|
.Where(p => p.Price > 500)
|
|
.ToPagedResult(1, 10);
|
|
|
|
// Assert
|
|
Assert.AreEqual(10, searchResults.Items.Count);
|
|
Assert.IsTrue(searchResults.Items.All(p => p.Price > 500));
|
|
Assert.IsTrue(searchResults.TotalCount > 40); // 总共有 50+ 个符合条件的产品
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Scenario_OrganizationTree()
|
|
{
|
|
// Arrange: 模拟组织架构树
|
|
var departments = new List<TestItem>
|
|
{
|
|
new() { Id = 1, Name = "总公司", ParentId = null },
|
|
new() { Id = 2, Name = "技术部", ParentId = 1 },
|
|
new() { Id = 3, Name = "市场部", ParentId = 1 },
|
|
new() { Id = 4, Name = "前端组", ParentId = 2 },
|
|
new() { Id = 5, Name = "后端组", ParentId = 2 },
|
|
new() { Id = 6, Name = "运营组", ParentId = 3 }
|
|
};
|
|
|
|
// Act: 构建组织树
|
|
var tree = departments.ToTree(x => x.Id, x => x.ParentId);
|
|
|
|
// Assert: 验证树形结构
|
|
Assert.AreEqual(1, tree.Count); // 1 个根节点（总公司）
|
|
Assert.AreEqual(2, tree[0].Children.Count); // 2 个一级部门
|
|
Assert.AreEqual(2, tree[0].Children[0].Children.Count); // 技术部有 2 个组
|
|
Assert.AreEqual("前端组", tree[0].Children[0].Children[0].Data.Name);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Scenario_BatchProcessing()
|
|
{
|
|
// Arrange: 模拟批量导入数据
|
|
var records = Enumerable.Range(1, 1000).ToList();
|
|
var processedCount = 0;
|
|
|
|
// Act: 每批处理 100 条记录
|
|
records.ForEachBatch(100, batch =>
|
|
{
|
|
// 模拟批量插入数据库
|
|
processedCount += batch.Count();
|
|
});
|
|
|
|
// Assert
|
|
Assert.AreEqual(1000, processedCount);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Scenario_DataCleaning()
|
|
{
|
|
// Arrange: 模拟清洗数据（去除 null、去重、过滤）
|
|
var rawData = new List<string?> { "A", null, "B", "A", null, "C", "B", "D" };
|
|
|
|
// Act: 数据清洗流水线
|
|
var cleanedData = rawData
|
|
.WhereNotNull() // 去除 null
|
|
.DistinctBy(x => x) // 去重
|
|
.Where(x => x != "D") // 过滤不需要的数据
|
|
.ToList();
|
|
|
|
// Assert
|
|
Assert.AreEqual(3, cleanedData.Count);
|
|
CollectionAssert.AreEqual(new[] { "A", "B", "C" }, cleanedData);
|
|
}
|
|
|
|
#endregion
|
|
} |