From deab005ea755850c5c15bdec36983c4130c9cf8e Mon Sep 17 00:00:00 2001 From: mlemanczyk Date: Mon, 25 Dec 2023 20:41:13 +0100 Subject: [PATCH] Properties & methods made strong typed. Their test case equivalents added. Methods & properties sorted, all made public. --- .../RecyclableLongListTestData.cs | 462 ++++++++++-------- 1 file changed, 267 insertions(+), 195 deletions(-) diff --git a/Recyclable.Collections.TestData/RecyclableLongListTestData.cs b/Recyclable.Collections.TestData/RecyclableLongListTestData.cs index 6dbc7cd..72d3b8f 100644 --- a/Recyclable.Collections.TestData/RecyclableLongListTestData.cs +++ b/Recyclable.Collections.TestData/RecyclableLongListTestData.cs @@ -1,199 +1,157 @@ using Open.Numeric.Primes; -using Recyclable.Collections; using System.Numerics; namespace Recyclable.Collections.TestData { public static class RecyclableLongListTestData { - public static object[] SourceRefData { get; } = Enumerable.Range(1, 100).Cast().ToArray(); - - public static IEnumerable CreateTestData(long itemsCount) + public static IEnumerable<(long ItemIndex, long RangeItemsCount)> CombineItemIndexWithRange(long itemIndex, long itemsCount) { - for (long index = 1; index <= itemsCount; index++) + return GenerateRanges(itemIndex, itemsCount).Distinct(); + + static IEnumerable<(long ItemIndex, long RangeItemsCount)> GenerateRanges(long itemIndex, long itemsCount) { - yield return index; + yield return (0L, Math.Max(itemIndex, 1L)); + yield return (itemIndex, Math.Max(itemsCount - itemIndex, 1L)); + yield return (itemIndex, 1L); + yield return (Math.Max(0L, itemIndex - 1L), Math.Max(Math.Min(itemsCount - itemIndex, 2L), 1L)); + + yield return (0L, 0L); + yield return (itemIndex, 0L); + yield return (Math.Max(0L, itemIndex - 1L), 0L); + + yield return (0L, 1L); + yield return (0L, Math.Max(itemIndex, 1L)); + yield return (0L, Math.Max(itemsCount - itemIndex, 1L)); + yield return (0L, 2L); + + var rangeSize = (int)Math.Min(itemsCount - itemIndex, 4); + yield return ((int)(rangeSize > 2 ? Math.Max(0, itemIndex - 2) : itemIndex), rangeSize); + + rangeSize = (int)Math.Max(Math.Min(itemsCount - itemIndex - 2, 4), 0); + yield return ((int)(rangeSize > 2 ? Math.Max(0, itemIndex - 2 - 1) : Math.Max(0, itemIndex - 1)), rangeSize); } } - public static IEnumerable CreateRefTestData(long itemsCount) - { - for (long index = 1; index <= itemsCount; index++) - { - yield return index; - } - } - - public static readonly IEnumerable ItemsCountVariants = new long[] - { - //RecyclableDefaults.MinPooledArrayLength - 5, RecyclableDefaults.MinPooledArrayLength - 1, RecyclableDefaults.MinPooledArrayLength, RecyclableDefaults.MinPooledArrayLength + 1, RecyclableDefaults.MinPooledArrayLength + 5, 127, 128, 129, RecyclableDefaults.MinItemsCountForParallelization - 0, 1, 2, 3, 7, 10, 16, RecyclableDefaults.MinPooledArrayLength - 5, RecyclableDefaults.MinPooledArrayLength - 1, RecyclableDefaults.MinPooledArrayLength, RecyclableDefaults.MinPooledArrayLength + 1, RecyclableDefaults.MinPooledArrayLength + 5, RecyclableDefaults.MinPooledArrayLength * 100 - }; - - public static readonly IEnumerable ItemsCountTestCases = ItemsCountVariants.Select(x => new object[] { (int)x }); - - public static readonly IEnumerable BlockSizeVariants = new int[] - { - 1, 2, 4, 16, RecyclableDefaults.MinPooledArrayLength - 5, (int)BitOperations.RoundUpToPowerOf2(RecyclableDefaults.MinPooledArrayLength) - }; - - private static bool IsValidBlockSize(long itemsCount, long blockSize) => itemsCount is < 1024 || blockSize is > 8; - - private static IEnumerable GetTargetDataVariants() - { - foreach (var itemsCount in ItemsCountVariants) - { - foreach (var targetBlockSize in BlockSizeVariants) - { - if (!IsValidBlockSize(itemsCount, targetBlockSize)) - { - continue; - } - - yield return new object[] { itemsCount, targetBlockSize }; - } - } - } - - public static IEnumerable TargetDataVariants => GetTargetDataVariants(); - - private static IEnumerable CombineSourceDataWithBlockSize(IEnumerable sourceData) + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> CombineSourceDataWithBlockSize(IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> sourceData) { foreach (var testData in sourceData) { foreach (var targetBlockSize in BlockSizeVariants) { - if (!IsValidBlockSize((long)testData[2], targetBlockSize)) + if (!IsValidBlockSize(testData.ItemsCount, targetBlockSize)) { continue; } - yield return new object[] { testData[0], testData[1], testData[2], targetBlockSize }; + yield return (testData.TestCase, testData.TestData, testData.ItemsCount, targetBlockSize); } } } - private static IEnumerable CreateSourceDataVariants(long itemsCount, bool refType) + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> CombineSourceDataWithBlockSize(IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> sourceData) { - GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true, true); - - switch (refType) + foreach (var testData in sourceData) { - case false: - long[] testData = CreateTestData(itemsCount).ToArray(); - - yield return new object[] { $"Array[{itemsCount}]", testData, itemsCount }; - yield return new object[] { $"ICollection[{itemsCount}]", new CustomICollection(testData), itemsCount }; - yield return new object[] { $"ICollection[{itemsCount}]", new CustomICollectionT(testData.ToList()), itemsCount }; - yield return new object[] { $"IEnumerable[{itemsCount}]", new EnumerableWithoutCount(testData), itemsCount }; - yield return new object[] { $"IEnumerable[{itemsCount}] without non-enumerated count", new EnumerableWithoutCount(testData), itemsCount }; - yield return new object[] { $"IList[{itemsCount}]", new CustomIList(testData), itemsCount }; - yield return new object[] { $"IList[{itemsCount}]", new CustomIListT(testData), itemsCount }; - yield return new object[] { $"IReadOnlyList[{itemsCount}])", new CustomIReadOnlyList(testData), itemsCount }; - yield return new object[] { $"List[{itemsCount}]", testData.ToList(), itemsCount }; - yield return new object[] { $"ReadOnlySpan[{itemsCount}]", testData, itemsCount }; - yield return new object[] { $"RecyclableList[{itemsCount}]", testData.ToRecyclableList(), itemsCount }; - - foreach (var sourceBlockSize in BlockSizeVariants) + foreach (var targetBlockSize in BlockSizeVariants) + { + if (!IsValidBlockSize(testData.ItemsCount, targetBlockSize)) { - if (!IsValidBlockSize(itemsCount, sourceBlockSize)) - { - continue; - } - - yield return new object[] - { - $"RecyclableLongList[itemsCount: {itemsCount}, minBlockSize: {sourceBlockSize}]", - testData.ToRecyclableLongList(sourceBlockSize), - itemsCount - }; + continue; } - yield return new object[] { $"Span[{itemsCount}]", testData, itemsCount }; - yield return new object[] { $"T[{itemsCount}]", testData, itemsCount }; - break; - - case true: - object[] testRefData = CreateRefTestData(itemsCount).ToArray(); - - yield return new object[] { $"Array[{itemsCount}]", testRefData, itemsCount }; - yield return new object[] { $"ICollection(itemsCount: {itemsCount}", new CustomICollection(testRefData), itemsCount }; - yield return new object[] { $"ICollection(itemsCount: {itemsCount}", new CustomICollectionT(testRefData.ToList()), itemsCount }; - yield return new object[] { $"IEnumerable(itemsCount: {itemsCount})", new EnumerableWithoutCount(testRefData), itemsCount }; - yield return new object[] { $"IEnumerable(itemsCount: {itemsCount}) without non-enumerated count", new EnumerableWithoutCount(testRefData), itemsCount }; - yield return new object[] { $"IList(itemsCount: {itemsCount})", new CustomIList(testRefData), itemsCount }; - yield return new object[] { $"IList(itemsCount: {itemsCount})", new CustomIListT(testRefData), itemsCount }; - yield return new object[] { $"IReadOnlyList(itemsCount: {itemsCount})", new CustomIReadOnlyList(testRefData), itemsCount }; - yield return new object[] { $"List(itemsCount: {itemsCount}", testRefData.ToList(), itemsCount }; - yield return new object[] { $"ReadOnlySpan[{itemsCount}]", testRefData, itemsCount }; - yield return new object[] { $"RecyclableList(itemsCount: {itemsCount})", testRefData.ToRecyclableList(), itemsCount }; - - foreach (var sourceBlockSize in BlockSizeVariants) - { - if (!IsValidBlockSize(itemsCount, sourceBlockSize)) - { - continue; - } - - yield return new object[] - { - $"RecyclableLongList(itemsCount: {itemsCount}, minBlockSize: {sourceBlockSize})", - testRefData.ToRecyclableLongList(sourceBlockSize), - itemsCount - }; - } - - yield return new object[] { $"Span[{itemsCount}]", testRefData, itemsCount }; - yield return new object[] { $"T[{itemsCount}]", testRefData, itemsCount }; - break; - } - } - - private static IEnumerable CreateSourceDataVariants(bool refType) - { - foreach (var itemsCount in ItemsCountVariants) - { - foreach (var variant in CreateSourceDataVariants(itemsCount, refType)) - { - yield return variant; + yield return (testData.TestCase, testData.TestData, testData.ItemsCount, targetBlockSize); } } } - public static IEnumerable EmptySourceDataVariants => CreateSourceDataVariants(0, false); - public static IEnumerable SourceDataVariants => CreateSourceDataVariants(false); - public static IEnumerable SourceDataWithItemIndexVariants + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable ItemIndexes)> CombineSourceDataWithBlockSizeWithItemIndex() { - get + IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> sourceData = CombineSourceDataWithBlockSize(CreateSourceDataVariants()); + + foreach (var testCase in sourceData) { - foreach (var testCase in CreateSourceDataVariants(false).Where(testCase => (long)testCase[2] > 0)) + long itemsCount = testCase.ItemsCount; + if (itemsCount == 0) { - var itemIndexes = CreateItemIndexVariants((long)testCase[2], RecyclableDefaults.BlockSize).ToArray(); - yield return new object[] { testCase[0], testCase[1], testCase[2], itemIndexes }; + continue; } + + long[] itemIndexes = CreateItemIndexVariants(itemsCount, testCase.BlockSize) + .Where(_ => IsValidBlockSize(testCase.ItemsCount, testCase.BlockSize)) + .ToArray(); + + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, testCase.BlockSize, itemIndexes); } } - public static IEnumerable SourceRefDataWithItemIndexVariants + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable<(long ItemIndex, long RangeItemsCount)> ItemsIndexesWithRange)> CombineSourceDataWithBlockSizeWithItemIndexWithRange() { - get + IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> sourceData = CombineSourceDataWithBlockSize(CreateSourceDataVariants()); + + foreach (var testCase in sourceData) { - IEnumerable testCases = CreateSourceDataVariants(true).Where(testCase => (long)testCase[2] > 0); - foreach (var testCase in testCases) + long itemsCount = testCase.ItemsCount; + if (itemsCount == 0) { - var itemIndexes = CreateItemIndexVariants((long)testCase[2], RecyclableDefaults.BlockSize).ToArray(); - - yield return new object[] { testCase[0], testCase[1], testCase[2], itemIndexes }; + continue; } + + var itemIndexes = CreateItemIndexVariants(itemsCount, (int)testCase.BlockSize) + .Where(_ => IsValidBlockSize(testCase.ItemsCount, testCase.BlockSize)); + + var itemIndexesWithRange = itemIndexes.SelectMany( + itemIndex => CombineItemIndexWithRange(itemIndex, itemsCount)) + .ToArray(); + + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, testCase.BlockSize, itemIndexesWithRange); } } - public static IEnumerable SourceDataWithBlockSizeVariants => CombineSourceDataWithBlockSize(SourceDataVariants); - public static IEnumerable SourceRefDataVariants => CreateSourceDataVariants(true); - public static IEnumerable SourceRefDataWithBlockSizeVariants { get; } = CombineSourceDataWithBlockSize(SourceRefDataVariants); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable ItemIndexes)> CombineSourceRefDataWithBlockSizeWithItemIndex() + { + IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> sourceData = CombineSourceDataWithBlockSize(CreateSourceRefDataVariants()); - private static IEnumerable InitialItemIndexVariants => new long[] { 0, 1, 2, 3, 4, 5 }; - private static IEnumerable CreateItemIndexVariants(long itemsCount, int blockSize) + foreach (var testCase in sourceData) + { + long itemsCount = testCase.ItemsCount; + if (itemsCount == 0) + { + continue; + } + + long[] itemIndexes = CreateItemIndexVariants(itemsCount, testCase.BlockSize) + .Where(_ => IsValidBlockSize(testCase.ItemsCount, testCase.BlockSize)) + .ToArray(); + + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, testCase.BlockSize, itemIndexes); + } + } + + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable<(long ItemIndex, long RangeItemsCount)> ItemsIndexesWithRange)> CombineSourceRefDataWithBlockSizeWithItemIndexWithRange() + { + IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> sourceData = CombineSourceDataWithBlockSize(CreateSourceRefDataVariants()); + + foreach (var testCase in sourceData) + { + long itemsCount = testCase.ItemsCount; + if (itemsCount == 0) + { + continue; + } + + var itemIndexes = CreateItemIndexVariants(itemsCount, testCase.BlockSize) + .Where(_ => IsValidBlockSize(testCase.ItemsCount, testCase.BlockSize)); + + var itemIndexesWithRange = itemIndexes.SelectMany( + itemIndex => CombineItemIndexWithRange(itemIndex, itemsCount)) + .ToArray(); + + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, testCase.BlockSize, itemIndexesWithRange); + } + } + + public static IEnumerable CreateItemIndexVariants(long itemsCount, int blockSize) { IEnumerable primes = InitialItemIndexVariants.Concat( InitialItemIndexVariants.SelectMany(index => new long[] { blockSize - index, blockSize + index }) @@ -251,84 +209,198 @@ namespace Recyclable.Collections.TestData //return CreateItemIndexVariants(); } - public static IEnumerable CombineSourceRefDataWithBlockSizeWithItemIndex(bool refType) + public static IEnumerable CreateRefTestData(long itemsCount) { - IEnumerable sourceData = refType switch + for (long index = 1; index <= itemsCount; index++) { - false => SourceDataWithBlockSizeVariants, - true => SourceRefDataWithBlockSizeVariants - }; + yield return index; + } + } - foreach (var testCase in sourceData) + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> CreateSourceDataVariants() + { + foreach (var itemsCount in ItemsCountVariants) { - long itemsCount = (long)testCase[2]; - if (itemsCount == 0) + foreach (var variant in CreateSourceDataVariants(itemsCount)) + { + yield return variant; + } + } + } + + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> CreateSourceDataVariants(long itemsCount) + { + GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true, true); + + long[] testData = CreateTestData(itemsCount).ToArray(); + + yield return ( $"Array[{itemsCount}]", testData, itemsCount ); + yield return ( $"ICollection[{itemsCount}]", new CustomICollection(testData), itemsCount ); + yield return ( $"ICollection[{itemsCount}]", new CustomICollectionT(testData.ToList()), itemsCount ); + yield return ( $"IEnumerable[{itemsCount}]", new EnumerableWithoutCount(testData), itemsCount ); + yield return ( $"IEnumerable[{itemsCount}] without non-enumerated count", new EnumerableWithoutCount(testData), itemsCount ); + yield return ( $"IList[{itemsCount}]", new CustomIList(testData), itemsCount ); + yield return ( $"IList[{itemsCount}]", new CustomIListT(testData), itemsCount ); + yield return ( $"IReadOnlyList[{itemsCount}])", new CustomIReadOnlyList(testData), itemsCount ); + yield return ( $"List[{itemsCount}]", testData.ToList(), itemsCount ); + yield return ( $"ReadOnlySpan[{itemsCount}]", testData, itemsCount ); + yield return ( $"RecyclableList[{itemsCount}]", testData.ToRecyclableList(), itemsCount ); + + foreach (var sourceBlockSize in BlockSizeVariants) + { + if (!IsValidBlockSize(itemsCount, sourceBlockSize)) { continue; } - long[] itemIndexes = CreateItemIndexVariants(itemsCount, (int)testCase[3]) - .Where(_ => IsValidBlockSize((long)testCase[2], (int)testCase[3])) - .ToArray(); + yield return + ( + $"RecyclableLongList[itemsCount: {itemsCount}, minBlockSize: {sourceBlockSize}]", + testData.ToRecyclableLongList(sourceBlockSize), + itemsCount + ); + } - yield return new object[] { testCase[0], testCase[1], (long)testCase[2], (int)testCase[3], itemIndexes }; + yield return ($"Span[{itemsCount}]", testData, itemsCount); + yield return ($"T[{itemsCount}]", testData, itemsCount); + } + + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> CreateSourceRefDataVariants() + { + foreach (var itemsCount in ItemsCountVariants) + { + foreach (var variant in CreateSourceRefDataVariants(itemsCount)) + { + yield return variant; + } } } - public static IEnumerable CombineSourceRefDataWithBlockSizeWithItemIndexWithRange(bool refType) + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> CreateSourceRefDataVariants(long itemsCount) { - IEnumerable sourceData = refType switch - { - false => SourceDataWithBlockSizeVariants, - true => SourceRefDataWithBlockSizeVariants - }; + GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true, true); - foreach (var testCase in sourceData) + object[] testRefData = CreateRefTestData(itemsCount).ToArray(); + + yield return ( $"Array[{itemsCount}]", testRefData, itemsCount ); + yield return ( $"ICollection(itemsCount: {itemsCount}", new CustomICollection(testRefData), itemsCount ); + yield return ( $"ICollection(itemsCount: {itemsCount}", new CustomICollectionT(testRefData.ToList()), itemsCount ); + yield return ( $"IEnumerable(itemsCount: {itemsCount})", new EnumerableWithoutCount(testRefData), itemsCount ); + yield return ( $"IEnumerable(itemsCount: {itemsCount}) without non-enumerated count", new EnumerableWithoutCount(testRefData), itemsCount ); + yield return ( $"IList(itemsCount: {itemsCount})", new CustomIList(testRefData), itemsCount ); + yield return ( $"IList(itemsCount: {itemsCount})", new CustomIListT(testRefData), itemsCount ); + yield return ( $"IReadOnlyList(itemsCount: {itemsCount})", new CustomIReadOnlyList(testRefData), itemsCount ); + yield return ( $"List(itemsCount: {itemsCount}", testRefData.ToList(), itemsCount ); + yield return ( $"ReadOnlySpan[{itemsCount}]", testRefData, itemsCount ); + yield return ( $"RecyclableList(itemsCount: {itemsCount})", testRefData.ToRecyclableList(), itemsCount ); + + foreach (var sourceBlockSize in BlockSizeVariants) { - long itemsCount = (long)testCase[2]; - if (itemsCount == 0) + if (!IsValidBlockSize(itemsCount, sourceBlockSize)) { continue; } - var itemIndexes = CreateItemIndexVariants(itemsCount, (int)testCase[3]) - .Where(_ => IsValidBlockSize((long)testCase[2], (int)testCase[3])); + yield return + ( + $"RecyclableLongList(itemsCount: {itemsCount}, minBlockSize: {sourceBlockSize})", + testRefData.ToRecyclableLongList(sourceBlockSize), + itemsCount + ); + } - var itemIndexesWithRange = itemIndexes.SelectMany( - itemIndex => CombineItemIndexWithRange(itemIndex, itemsCount)) - .ToArray(); + yield return ($"Span[{itemsCount}]", testRefData, itemsCount); + yield return ($"T[{itemsCount}]", testRefData, itemsCount); + } - yield return new object[] { testCase[0], testCase[1], (long)testCase[2], (int)testCase[3], itemIndexesWithRange }; + public static IEnumerable<(long ItemsCount, int BlockSize)> CreateTargetDataVariants() + { + foreach (var itemsCount in ItemsCountVariants) + { + foreach (var targetBlockSize in BlockSizeVariants) + { + if (!IsValidBlockSize(itemsCount, targetBlockSize)) + { + continue; + } + + yield return (itemsCount, targetBlockSize); + } } } - public static IEnumerable<(long ItemIndex, long RangeItemsCount)> CombineItemIndexWithRange(long itemIndex, long itemsCount) + public static IEnumerable CreateTestData(long itemsCount) { - yield return (0L, Math.Max(itemIndex, 1L)); - yield return (itemIndex, Math.Max(itemsCount - itemIndex, 1L)); - yield return (itemIndex, 1L); - yield return (Math.Max(0L, itemIndex - 1L), Math.Max(Math.Min(itemsCount - itemIndex, 2L), 1L)); + for (long index = 1; index <= itemsCount; index++) + { + yield return index; + } + } + public static bool IsValidBlockSize(long itemsCount, long blockSize) => itemsCount is < 1024 || blockSize is > 8; - yield return (0L, 0L); - yield return (itemIndex, 0L); - yield return (Math.Max(0L, itemIndex - 1L), 0L); + public static readonly IEnumerable BlockSizeVariants = new int[] + { + 1, 2, 4, 16, RecyclableDefaults.MinPooledArrayLength - 5, (int)BitOperations.RoundUpToPowerOf2(RecyclableDefaults.MinPooledArrayLength) + }; - yield return (0L, 1L); - yield return (0L, Math.Max(itemIndex, 1L)); - yield return (0L, Math.Max(itemIndex, 1L)); - yield return (0L, Math.Max(itemsCount - itemIndex, 1L)); - yield return (0L, Math.Max(Math.Min(itemsCount - itemIndex, 2L), 1L)); + public static IEnumerable EmptySourceDataTestCases => EmptySourceDataVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> EmptySourceDataVariants => CreateSourceDataVariants(0); + public static IEnumerable InitialItemIndexVariants => new long[] { 0, 1, 2, 3, 4, 5 }; - var rangeSize = (int)Math.Min(itemsCount - itemIndex, 4); - yield return ((int)(rangeSize > 2 ? Math.Max(0, itemIndex - 2) : itemIndex), rangeSize); + public static readonly IEnumerable ItemsCountVariants = new long[] + { + //RecyclableDefaults.MinPooledArrayLength - 5, RecyclableDefaults.MinPooledArrayLength - 1, RecyclableDefaults.MinPooledArrayLength, RecyclableDefaults.MinPooledArrayLength + 1, RecyclableDefaults.MinPooledArrayLength + 5, 127, 128, 129, RecyclableDefaults.MinItemsCountForParallelization + 0, 1, 2, 3, 7, 10, 16, RecyclableDefaults.MinPooledArrayLength - 5, RecyclableDefaults.MinPooledArrayLength - 1, RecyclableDefaults.MinPooledArrayLength, + RecyclableDefaults.MinPooledArrayLength + 1, RecyclableDefaults.MinPooledArrayLength + 5, RecyclableDefaults.MinPooledArrayLength * 100 + }; - rangeSize = (int)Math.Max(Math.Min(itemsCount - itemIndex - 2, 4), 0); - yield return ((int)(rangeSize > 2 ? Math.Max(0, itemIndex - 2 - 1) : Math.Max(0, itemIndex - 1)), rangeSize); + public static readonly IEnumerable ItemsCountTestCases = ItemsCountVariants.Select(x => new object[] { (int)x }); + public static IEnumerable SourceDataTestCases => SourceDataVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> SourceDataVariants => CreateSourceDataVariants(); + public static IEnumerable SourceDataWithBlockSizeTestCases => SourceDataWithBlockSizeVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> SourceDataWithBlockSizeVariants => CombineSourceDataWithBlockSize(CreateSourceDataVariants()); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable ItemIndexes)> SourceDataWithBlockSizeWithItemIndexVariants { get; } = CombineSourceDataWithBlockSizeWithItemIndex(); + public static IEnumerable SourceDataWithBlockSizeWithItemIndexTestCases { get; } = SourceDataWithBlockSizeWithItemIndexVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize, x.ItemIndexes }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable<(long ItemIndex, long RangeItemsCount)> ItemsIndexesWithRange)> SourceDataWithBlockSizeWithItemIndexWithRangeVariants { get; } = CombineSourceDataWithBlockSizeWithItemIndexWithRange(); + public static IEnumerable SourceDataWithBlockSizeWithItemIndexWithRangeTestCases { get; } = SourceDataWithBlockSizeWithItemIndexWithRangeVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize, x.ItemsIndexesWithRange }); + public static IEnumerable SourceDataWithItemIndexTestCases => SourceDataWithItemIndexVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.ItemIndexes }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, IEnumerable ItemIndexes)> SourceDataWithItemIndexVariants + { + get + { + foreach (var testCase in CreateSourceDataVariants().Where(testCase => testCase.ItemsCount > 0)) + { + var itemIndexes = CreateItemIndexVariants(testCase.ItemsCount, RecyclableDefaults.BlockSize).ToArray(); + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, itemIndexes); + } + } } - public static IEnumerable SourceDataWithBlockSizeWithItemIndexVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndex(false); - public static IEnumerable SourceDataWithBlockSizeWithItemIndexWithRangeVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndexWithRange(false); - public static IEnumerable SourceRefDataWithBlockSizeWithItemIndexVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndex(true); - public static IEnumerable SourceRefDataWithBlockSizeWithItemIndexWithRangeVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndexWithRange(true); + public static object[] SourceRefData { get; } = Enumerable.Range(1, 100).Cast().ToArray(); + public static IEnumerable SourceRefDataTestCases => SourceRefDataVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> SourceRefDataVariants => CreateSourceRefDataVariants(); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize)> SourceRefDataWithBlockSizeVariants { get; } = CombineSourceDataWithBlockSize(CreateSourceRefDataVariants()); + public static IEnumerable SourceRefDataWithBlockSizeTestCases { get; } = SourceRefDataWithBlockSizeVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable ItemIndexes)> SourceRefDataWithBlockSizeWithItemIndexVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndex(); + public static IEnumerable SourceRefDataWithBlockSizeWithItemIndexTestCases { get; } = SourceRefDataWithBlockSizeWithItemIndexVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize, x.ItemIndexes }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, int BlockSize, IEnumerable<(long ItemIndex, long RangeItemsCount)> ItemsIndexesWithRange)> SourceRefDataWithBlockSizeWithItemIndexWithRangeVariants { get; } = CombineSourceRefDataWithBlockSizeWithItemIndexWithRange(); + public static IEnumerable SourceRefDataWithBlockSizeWithItemIndexWithRangeTestCases { get; } = SourceRefDataWithBlockSizeWithItemIndexWithRangeVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.BlockSize, x.ItemsIndexesWithRange }); + public static IEnumerable SourceRefDataWithItemIndexTestCases => SourceRefDataWithItemIndexVariants.Select(x => new object[] { x.TestCase, x.TestData, x.ItemsCount, x.ItemIndexes }); + public static IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount, IEnumerable ItemIndexes)> SourceRefDataWithItemIndexVariants + { + get + { + IEnumerable<(string TestCase, IEnumerable TestData, long ItemsCount)> testCases = CreateSourceRefDataVariants().Where(testCase => testCase.ItemsCount > 0); + foreach (var testCase in testCases) + { + var itemIndexes = CreateItemIndexVariants(testCase.ItemsCount, RecyclableDefaults.BlockSize).ToArray(); + + yield return (testCase.TestCase, testCase.TestData, testCase.ItemsCount, itemIndexes); + } + } + } + + public static IEnumerable TargetDataTestCases => TargetDataVariants.Select(x => new object[] { x.ItemsCount, x.BlockSize }); + public static IEnumerable<(long ItemsCount, int BlockSize)> TargetDataVariants => CreateTargetDataVariants(); } } \ No newline at end of file