Repeating pattern values for BitAutoData attribute (#5167)

* Repeating pattern values for BitAutoData attribute

* nullable enabled, added documentation

* execute test method even if no repeating pattern data provided (empty array).

* RepeatingPatternBitAutoDataAttribute unit tests

test/Common/AutoFixture/Attributes/RepeatingPatternBitAutoDataAttribute.cs

@@ -0,0 +1,112 @@
+#nullable enable
+using System.Reflection;
+
+namespace Bit.Test.Common.AutoFixture.Attributes;
+
+/// <summary>
+/// This attribute helps to generate all possible combinations of the provided pattern values for a given number of parameters.
+/// <remarks>
+/// <para>
+/// The repeating pattern values should be provided as an array for each parameter. Currently supports up to 3 parameters.
+/// </para>
+/// <para>
+/// The attribute is a variation of the <see cref="BitAutoDataAttribute"/> attribute and can be used in the same way, except that all fixed value parameters needs to be provided as an array.
+/// </para>
+/// <para>
+/// Note: Use it with caution. While this attribute is useful for handling repeating parameters, having too many parameters should be avoided as it is considered a code smell in most of the cases.
+/// If your test requires more than 2 repeating parameters, or the test have too many conditions that change the behavior of the test, consider refactoring the test by splitting it into multiple smaller ones.
+/// </para>
+/// </remarks>
+/// <example>
+/// 1st example:
+/// <code>
+/// [RepeatingPatternBitAutoData([false], [1,2,3])]
+/// public void TestMethod(bool first, int second, SomeOtherData third, ...)
+/// </code>
+/// Would generate the following test cases:
+/// <list type="bullet">
+/// <item>false, 1</item>
+/// <item>false, 2</item>
+/// <item>false, 3</item>
+/// </list>
+/// 2nd example:
+/// <code>
+/// [RepeatingPatternBitAutoData([false, true], [false, true], [false, true])]
+/// public void TestMethod(bool first, bool second, bool third)
+/// </code>
+/// Would generate the following test cases:
+/// <list type="bullet">
+/// <item>false, false, false</item>
+/// <item>false, false, true</item>
+/// <item>false, true, false</item>
+/// <item>false, true, true</item>
+/// <item>true, false, false</item>
+/// <item>true, false, true</item>
+/// <item>true, true, false</item>
+/// <item>true, true, true</item>
+/// </list>
+/// </example>
+/// </summary>
+public class RepeatingPatternBitAutoDataAttribute : BitAutoDataAttribute
+{
+    private readonly List<object?[]> _repeatingDataList;
+
+    public RepeatingPatternBitAutoDataAttribute(object?[] first)
+    {
+        _repeatingDataList = AllValues([first]);
+    }
+
+    public RepeatingPatternBitAutoDataAttribute(object?[] first, object?[] second)
+    {
+        _repeatingDataList = AllValues([first, second]);
+    }
+
+    public RepeatingPatternBitAutoDataAttribute(object?[] first, object?[] second, object?[] third)
+    {
+        _repeatingDataList = AllValues([first, second, third]);
+    }
+
+    public override IEnumerable<object?[]> GetData(MethodInfo testMethod)
+    {
+        if (_repeatingDataList.Count == 0)
+        {
+            yield return base.GetData(testMethod).First();
+        }
+
+        foreach (var repeatingData in _repeatingDataList)
+        {
+            var bitData = base.GetData(testMethod).First();
+            for (var i = 0; i < repeatingData.Length; i++)
+            {
+                bitData[i] = repeatingData[i];
+            }
+
+            yield return bitData;
+        }
+    }
+
+    private static List<object?[]> AllValues(object?[][] parameterToPatternValues)
+    {
+        var result = new List<object?[]>();
+        GenerateCombinations(parameterToPatternValues, new object[parameterToPatternValues.Length], 0, result);
+        return result;
+    }
+
+    private static void GenerateCombinations(object?[][] parameterToPatternValues, object?[] current, int index,
+        List<object?[]> result)
+    {
+        if (index == current.Length)
+        {
+            result.Add((object[])current.Clone());
+            return;
+        }
+
+        var patternValues = parameterToPatternValues[index];
+
+        foreach (var value in patternValues)
+        {
+            current[index] = value;
+            GenerateCombinations(parameterToPatternValues, current, index + 1, result);
+        }
+    }
+}

test/Common/AutoFixture/Attributes/RepeatingPatternBitAutoDataAttributeTests.cs

@@ -0,0 +1,290 @@
+#nullable enable
+using Xunit;
+
+namespace Bit.Test.Common.AutoFixture.Attributes;
+
+public class RepeatingPatternBitAutoDataAttributeTests
+{
+    public class OneParam1 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public OneParam1(TestDataContext context)
+        {
+            context.SetData(1, [], [], []);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([])]
+        public void NoPattern_NoTestExecution(string autoDataFilled)
+        {
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class OneParam2 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public OneParam2(TestDataContext context)
+        {
+            context.SetData(2, [false, true], [], []);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([false, true])]
+        public void TrueFalsePattern_2Executions(bool first, string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedBooleans1.Remove(first));
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class OneParam3 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public OneParam3(TestDataContext context)
+        {
+            context.SetData(4, [], [], [null, "", " ", "\t"]);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([null, "", " ", "\t"])]
+        public void NullableEmptyStringPattern_4Executions(string? first, string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedStrings.Remove(first));
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class OneParam4 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public OneParam4(TestDataContext context)
+        {
+            context.SetData(6, [], [], [null, "", " ", "\t", "\n", " \t\n"]);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([null, "", " ", "\t"])] // 4 executions
+        [BitAutoData("\n")] // 1 execution
+        [BitAutoData(" \t\n", "test data")] // 1 execution
+        public void MixedPatternsWithBitAutoData_6Executions(string? first, string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedStrings.Remove(first));
+            Assert.NotEmpty(autoDataFilled);
+            if (first == " \t\n")
+            {
+                Assert.Equal("test data", autoDataFilled);
+            }
+
+            _context.TestExecuted();
+        }
+    }
+
+    public class TwoParams1 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public TwoParams1(TestDataContext context)
+        {
+            context.SetData(8, TestDataContext.GenerateData([false, true], 4), [],
+                TestDataContext.GenerateData([null, "", " ", "\t"], 2));
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([false, true], [null, "", " ", "\t"])]
+        public void TrueFalsePatternFirstNullableEmptyStringPatternSecond_8Executions(
+            bool first, string? second,
+            string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedBooleans1.Remove(first));
+            Assert.True(_context.ExpectedStrings.Remove(second));
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class TwoParams2 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public TwoParams2(TestDataContext context)
+        {
+            context.SetData(8, TestDataContext.GenerateData([false, true], 4), [],
+                TestDataContext.GenerateData([null, "", " ", "\t"], 2));
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([null, "", " ", "\t"], [false, true])]
+        public void NullableEmptyStringPatternFirstTrueFalsePatternSecond_8Executions(
+            string? first, bool second,
+            string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedStrings.Remove(first));
+            Assert.True(_context.ExpectedBooleans1.Remove(second));
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class TwoParams3 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public TwoParams3(TestDataContext context)
+        {
+            var expectedBooleans1 = TestDataContext.GenerateData([false], 4);
+            expectedBooleans1.AddRange(TestDataContext.GenerateData([true], 5));
+            var expectedStrings = TestDataContext.GenerateData([null, "", " "], 2);
+            expectedStrings.AddRange(["\t", "\n", " \t\n"]);
+            context.SetData(9, expectedBooleans1, [], expectedStrings);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([null, "", " "], [false, true])] // 6 executions
+        [RepeatingPatternBitAutoData(["\t"], [false])] // 1 execution
+        [BitAutoData("\n", true)] // 1 execution
+        [BitAutoData(" \t\n", true, "test data")] // 1 execution
+        public void MixedPatternsWithBitAutoData_9Executions(
+            string? first, bool second,
+            string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedStrings.Remove(first));
+            Assert.True(_context.ExpectedBooleans1.Remove(second));
+            Assert.NotEmpty(autoDataFilled);
+            if (first == " \t\n")
+            {
+                Assert.Equal("test data", autoDataFilled);
+            }
+
+            _context.TestExecuted();
+        }
+    }
+
+    public class ThreeParams1 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public ThreeParams1(TestDataContext context)
+        {
+            context.SetData(16, TestDataContext.GenerateData([false, true], 8),
+                TestDataContext.GenerateData([false, true], 8),
+                TestDataContext.GenerateData([null, "", " ", "\t"], 4));
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([false, true], [null, "", " ", "\t"], [false, true])]
+        public void TrueFalsePatternFirstNullableEmptyStringPatternSecondFalsePatternThird_16Executions(
+            bool first, string? second, bool third,
+            string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedBooleans1.Remove(first));
+            Assert.True(_context.ExpectedStrings.Remove(second));
+            Assert.True(_context.ExpectedBooleans2.Remove(third));
+            Assert.NotEmpty(autoDataFilled);
+            _context.TestExecuted();
+        }
+    }
+
+    public class ThreeParams2 : IClassFixture<TestDataContext>
+    {
+        private readonly TestDataContext _context;
+
+        public ThreeParams2(TestDataContext context)
+        {
+            var expectedBooleans1 = TestDataContext.GenerateData([false, true], 6);
+            expectedBooleans1.AddRange(TestDataContext.GenerateData([true], 3));
+            var expectedBooleans2 = TestDataContext.GenerateData([false, true], 7);
+            expectedBooleans2.Add(true);
+            var expectedStrings = TestDataContext.GenerateData([null, "", " "], 4);
+            expectedStrings.AddRange(["\t", "\t", " \t\n"]);
+            context.SetData(15, expectedBooleans1, expectedBooleans2, expectedStrings);
+            _context = context;
+        }
+
+        [Theory]
+        [RepeatingPatternBitAutoData([false, true], [null, "", " "], [false, true])] // 12 executions
+        [RepeatingPatternBitAutoData([true], ["\t"], [false, true])] // 2 executions
+        [BitAutoData(true, " \t\n", true, "test data")] // 1 execution
+        public void MixedPatternsWithBitAutoData_15Executions(
+            bool first, string? second, bool third,
+            string autoDataFilled)
+        {
+            Assert.True(_context.ExpectedBooleans1.Remove(first));
+            Assert.True(_context.ExpectedStrings.Remove(second));
+            Assert.True(_context.ExpectedBooleans2.Remove(third));
+            Assert.NotEmpty(autoDataFilled);
+            if (second == " \t\n")
+            {
+                Assert.Equal("test data", autoDataFilled);
+            }
+
+            _context.TestExecuted();
+        }
+    }
+}
+
+public class TestDataContext : IDisposable
+{
+    internal List<bool> ExpectedBooleans1 = [];
+    internal List<bool> ExpectedBooleans2 = [];
+
+    internal List<string?> ExpectedStrings = [];
+
+    private int _expectedExecutionCount;
+    private bool _dataSet;
+
+    public void TestExecuted()
+    {
+        _expectedExecutionCount--;
+    }
+
+    public void SetData(int expectedExecutionCount, List<bool> expectedBooleans1, List<bool> expectedBooleans2,
+        List<string?> expectedStrings)
+    {
+        if (_dataSet)
+        {
+            return;
+        }
+
+        _expectedExecutionCount = expectedExecutionCount;
+        ExpectedBooleans1 = expectedBooleans1;
+        ExpectedBooleans2 = expectedBooleans2;
+        ExpectedStrings = expectedStrings;
+
+        _dataSet = true;
+    }
+
+    public static List<T> GenerateData<T>(List<T> list, int count)
+    {
+        var repeatedList = new List<T>();
+        for (var i = 0; i < count; i++)
+        {
+            repeatedList.AddRange(list);
+        }
+
+        return repeatedList;
+    }
+
+    public void Dispose()
+    {
+        Assert.Equal(0, _expectedExecutionCount);
+        Assert.Empty(ExpectedBooleans1);
+        Assert.Empty(ExpectedBooleans2);
+        Assert.Empty(ExpectedStrings);
+    }
+}