Introduce attributes to refine customizations

README.md

@@ -153,7 +153,7 @@ An attribute that can be applied to parameters in an `AutoDataAttribute`-driven
 
 This attribute allows to disable the generation of members marked as `virtual` on a decorated type wheres `IgnoreVirtualMembers` arguments of mocking attributes mentioned above disable such a generation for all types created by `IFixture`.
 
-**Caution:** Order is important! Applying `IgnoreVirtualMembers` attribute to the subsequent paramater makes precedig parameters of the same type to have `virtual` properties populated and the particular parameter with the following ones of the same type to have `virtual` properties unpopulated.
+**Caution:** Order is important! Applying `IgnoreVirtualMembers` attribute to the subsequent parameter makes preceding parameters of the same type to have `virtual` properties populated and the particular parameter with the following ones of the same type to have `virtual` properties unpopulated.
 
 #### Example
 
@@ -192,7 +192,7 @@ An attribute that can be applied to parameters in an `AutoDataAttribute`-driven
 
 - IncludeParameterType - indicates whether attribute target parameter `Type` should included as a first argument when creating customization; by default set to `false`
 
-**Caution:** Order is important! Applying `CustomizeWith` attribute to the subsequent paramater makes precedig parameters of the same type to be created without specified customization and the particular parameter with the specified customization.
+**Caution:** Order is important! Applying `CustomizeWith` attribute to the subsequent parameter makes preceding parameters of the same type to be created without specified customization and the particular parameter with the specified customization.
 
 #### Example
 
@@ -285,6 +285,66 @@ public void CustomizeWithAttributeUsage(
 
 ***
 
+## Data filtering attributes
+
+The following attributes helps narrowing down data generation to specific values or omitting certain values.
+
+For these attributes to work, they must be used in conjunction with other data generation attributes.
+
+They can be applied to simple types and collections.
+
+### Except
+
+An attribute ensuring that values from outside the specified list will be generated.
+
+#### Example
+
+```csharp
+[Theory]
+[AutoData]
+public void ExceptAttributeUsage(
+    [Except(DayOfWeek.Saturday, DayOfWeek.Sunday)] DayOfWeek workday)
+{
+    Assert.True(workday is >= DayOfWeek.Monday and <= DayOfWeek.Friday);
+}
+```
+
+### Range
+
+An attribute ensuring that only values from specified range will be generated.
+
+#### Example
+
+```csharp
+[Theory]
+[AutoData]
+public void RangeAttributeUsage(
+    [Range(11, 19)] int teenagerAge)
+{
+    Assert.True(teenagerAge is > 11 and < 19);
+}
+```
+
+### Values
+
+An attribute ensuring that only values from the specified list will be generated.
+
+#### Example
+
+```csharp
+[Theory]
+[AutoData]
+public void ValuesAttributeUsage(
+    [Values(DayOfWeek.Saturday, DayOfWeek.Sunday)] HashSet<DayOfWeek> weekend)
+{
+    var weekendDays = new[] { DayOfWeek.Saturday, DayOfWeek.Sunday };
+    Assert.Equal(weekendDays.Length, weekend.Count);
+    Assert.All(weekendDays, (day) => Assert.Contains(day, weekend));
+}
+```
+
+***
+
 ## Tips and tricks
 
 ### Fixture injection

src/.editorconfig

@@ -183,7 +183,7 @@ roslynator_equals_token_new_line = after
 roslynator_infinite_loop_style = while
 roslynator_max_line_length = 500
 roslynator_new_line_at_end_of_file = true
-roslynator_new_line_before_while_in_do_statement = false
+roslynator_new_line_before_while_in_do_statement = true
 roslynator_null_conditional_operator_new_line = after
 roslynator_null_check_style = pattern_matching
 roslynator_object_creation_parentheses_style = include
@@ -1368,7 +1368,7 @@ dotnet_diagnostic.RCS1235.severity = warning
 dotnet_diagnostic.RCS1236.severity = warning
 
 # RCS1237: Use bit shift operator.
-dotnet_diagnostic.RCS1237.severity = suggestion
+dotnet_diagnostic.RCS1237.severity = none
 
 # RCS1238: Avoid nested ?: operators.
 dotnet_diagnostic.RCS1238.severity = suggestion
@@ -2176,6 +2176,9 @@ dotnet_diagnostic.CA1849.severity = warning
 # CA1850: Prefer static 'HashData' method over 'ComputeHash'
 dotnet_diagnostic.CA1850.severity = warning
 
+# CA1859: Use concrete types when possible for improved performance
+dotnet_diagnostic.CA1859.severity = suggestion
+
 # CA2000: Dispose objects before losing scope
 dotnet_diagnostic.CA2000.severity = warning
 dotnet_code_quality.CA2000.excluded_symbol_names = 
@@ -3284,7 +3287,7 @@ dotnet_diagnostic.SA1519.severity = error
 dotnet_diagnostic.SA1520.severity = error
 dotnet_diagnostic.SA1600.severity = none
 dotnet_diagnostic.SA1601.severity = none
-dotnet_diagnostic.SA1602.severity = error
+dotnet_diagnostic.SA1602.severity = none
 dotnet_diagnostic.SA1603.severity = error
 dotnet_diagnostic.SA1604.severity = error
 dotnet_diagnostic.SA1605.severity = error

src/Objectivity.AutoFixture.XUnit2.Core.Tests/.editorconfig

@@ -12,6 +12,8 @@ dotnet_diagnostic.CA1707.severity = none
 dotnet_diagnostic.CA1822.severity = none
 # CA1859: Use concrete types when possible for improved performance
 dotnet_diagnostic.CA1859.severity = none
+# CA1861: Avoid constant arrays as arguments
+dotnet_diagnostic.CA1861.severity = none
 # CA2000: Dispose objects before losing scope
 dotnet_diagnostic.CA2000.severity = none
 # CA2007: Consider calling ConfigureAwait on the awaited task

src/Objectivity.AutoFixture.XUnit2.Core.Tests/Attributes/CustomizeWithAttributeTests.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
     using System.Linq;
     using System.Reflection;
 
@@ -10,6 +11,7 @@
     using global::AutoFixture;
     using global::AutoFixture.Kernel;
     using global::AutoFixture.Xunit2;
+
     using Objectivity.AutoFixture.XUnit2.Core.Attributes;
     using Objectivity.AutoFixture.XUnit2.Core.Customizations;
 
@@ -123,9 +125,9 @@ public void GivenCustomizeWithAttributeWithIncludeParameterTypeSet_WhenGetCustom
             customization.Args.Should().HaveCount(1).And.Subject.First().Should().Be(parameter.ParameterType);
         }
 
-        [Theory(DisplayName = "GIVEN CustomizeWith attribute with arguments WHEN GetCustomization is invoked THEN expected customization is returned with expected numner of arguments")]
+        [Theory(DisplayName = "GIVEN CustomizeWith attribute with arguments WHEN GetCustomization is invoked THEN expected customization is returned with expected number of arguments")]
         [MemberData(nameof(ArgumentsDiscoveryCustomizationTestData))]
-        public void GivenCustomizeWithAttributeWithArguments_WhenGetCustomizationIsInvoked_ThenExpectedCustomizationIsReturnedWithExpectedNumnerOfArguments(bool includeParameterType, object[] args, int expectedNumberOfArguments)
+        public void GivenCustomizeWithAttributeWithArguments_WhenGetCustomizationIsInvoked_ThenExpectedCustomizationIsReturnedWithExpectedNumberOfArguments(bool includeParameterType, object[] args, int expectedNumberOfArguments)
         {
             // Arrange
             var customizationType = typeof(ArgumentsDiscoveryCustomization);
@@ -169,9 +171,9 @@ public void GivenCustomizeWithAppliedToTheFirstArgument_WhenDataPopulated_ThenAl
             instanceWithCustomization.Should().BeEmpty();
         }
 
-        [Theory(DisplayName = "GIVEN CustomizeWith applied to the first argument of a cecrtain type WHEN data populated THEN only the first one has customization")]
+        [Theory(DisplayName = "GIVEN CustomizeWith applied to the first argument of a certain type WHEN data populated THEN only the first one has customization")]
         [AutoData]
-        public void GivenCustomizeWithAppliedToTheFirstArgumentOfACecrtainType_WhenDataPopulated_ThenOnlyTheFirstOneHasCustomization(
+        public void GivenCustomizeWithAppliedToTheFirstArgumentOfACertainType_WhenDataPopulated_ThenOnlyTheFirstOneHasCustomization(
             [EmptyCollection] IList<string> instanceWithCustomization,
             IList<int?> instanceOfDifferentTypeWithoutCustomization)
         {
@@ -182,8 +184,8 @@ public void GivenCustomizeWithAppliedToTheFirstArgumentOfACecrtainType_WhenDataP
             instanceOfDifferentTypeWithoutCustomization.Should().NotBeEmpty();
         }
 
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1163:Unused parameter.", Justification = "Required for test")]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "Required for test")]
+        [SuppressMessage("Roslynator", "RCS1163:Unused parameter.", Justification = "Required for test")]
+        [SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "Required for test")]
         protected void MethodUnderTest(bool parameter)
         {
             // Empty method under test

src/Objectivity.AutoFixture.XUnit2.Core.Tests/Attributes/ExceptAttributeTests.cs

@@ -0,0 +1,187 @@
+namespace Objectivity.AutoFixture.XUnit2.Core.Tests.Attributes
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+
+    using FluentAssertions;
+
+    using global::AutoFixture;
+    using global::AutoFixture.Kernel;
+    using global::AutoFixture.Xunit2;
+
+    using Moq;
+
+    using Objectivity.AutoFixture.XUnit2.Core.Attributes;
+
+    using Xunit;
+
+    [Collection("ExceptAttribute")]
+    [Trait("Category", "Attributes")]
+    public class ExceptAttributeTests
+    {
+        public enum Numbers
+        {
+            None = 0,
+            One = 1,
+            Two = 2,
+            Three = 4,
+            Four = 8,
+            Five = 16,
+        }
+
+        public static IEnumerable<object[]> CustomizationUsageTestData { get; } = new[]
+        {
+            new object[] { 1 },
+            new object[] { 1.5f },
+            new object[] { "test" },
+            new object[] { false },
+            new object[] { Numbers.Five },
+            new object[] { DateTime.Now },
+            new object[] { ValueTuple.Create(5) },
+            new object[] { Tuple.Create(1, 2) },
+        };
+
+        [Fact(DisplayName = "GIVEN uninitialized argument WHEN constructor is invoked THEN exception is thrown")]
+        public void GivenUninitializedArgument_WhenConstructorIsInvoked_ThenExceptionIsThrown()
+        {
+            // Arrange
+            // Act
+            // Assert
+            Assert.Throws<ArgumentNullException>(() => new ExceptAttribute(null));
+        }
+
+        [Fact(DisplayName = "GIVEN no arguments WHEN constructor is invoked THEN exception is thrown")]
+        public void GivenNoArguments_WhenConstructorIsInvoked_ThenExceptionIsThrown()
+        {
+            // Arrange
+            // Act
+            // Assert
+            Assert.Throws<ArgumentException>(() => new ExceptAttribute());
+        }
+
+        [InlineData(1, 1)]
+        [InlineData("a", "a")]
+        [Theory(DisplayName = "GIVEN identical arguments WHEN constructor is invoked THEN unique parameters are properly assigned")]
+        public void GivenIdenticalArguments_WhenConstructorIsInvoked_ThenUniqueParametersAreProperlyAssigned(
+            object first,
+            object second)
+        {
+            // Arrange
+            var attribute = new ExceptAttribute(first, second);
+
+            // Assert
+            attribute.Values.Should().HaveCount(1).And.BeEquivalentTo(new[] { first });
+        }
+
+        [InlineData(typeof(int), 2)]
+        [InlineData(1, typeof(int))]
+        [Theory(DisplayName = "GIVEN incomparable argument WHEN constructor is invoked THEN parameters are properly assigned")]
+        public void GivenIncomparableArgument_WhenConstructorIsInvoked_ThenParametersAreProperlyAssigned(
+            object first,
+            object second)
+        {
+            // Arrange
+            // Act
+            var attribute = new ExceptAttribute(first, second);
+
+            // Assert
+            attribute.Values.Should().HaveCount(2).And.BeEquivalentTo(new[] { first, second });
+        }
+
+        [MemberData(nameof(CustomizationUsageTestData))]
+        [Theory(DisplayName = "GIVEN valid parameters WHEN customization is used THEN expected values are generated")]
+        public void GivenValidParameters_WhenCustomizationIsUsed_ThenExpectedValuesAreGenerated(
+            object item)
+        {
+            // Arrange
+            var attribute = new ExceptAttribute(item);
+            var request = new Mock<ParameterInfo>();
+            var expectedType = item.GetType();
+            request.SetupGet(x => x.ParameterType)
+                .Returns(expectedType);
+            IFixture fixture = new Fixture();
+            fixture.Customize(attribute.GetCustomization(request.Object));
+
+            // Act
+            var result = fixture.Create(request.Object, new SpecimenContext(fixture));
+
+            // Assert
+            result.Should().NotBeNull()
+                .And.BeOfType(expectedType)
+                .And.NotBe(item);
+        }
+
+        [AutoData]
+        [Theory(DisplayName = "GIVEN multiple values specified but one WHEN values populated THEN the one value is used")]
+        public void GivenMultipleValuesSpecifiedButOne_WhenValuesPopulated_ThenTheOneValueIsUsed(
+            [Except(
+                Numbers.None,
+                Numbers.One,
+                Numbers.Two,
+                Numbers.Three,
+                Numbers.Four)] Numbers[] targetValues)
+        {
+            // Arrange
+            // Act
+            // Assert
+            targetValues.Should().AllSatisfy(x => x.Should().Be(Numbers.Five));
+        }
+
+        [AutoData]
+        [Theory(DisplayName = "GIVEN values specified only for one set WHEN values populated THEN the other set is not impacted")]
+        public void GivenValuesSpecifiedOnlyForOneSet_WhenValuesPopulated_ThenTheOtherSetIsNotImpacted(
+            [Except(
+                Numbers.None,
+                Numbers.One,
+                Numbers.Two,
+                Numbers.Three,
+                Numbers.Four)] Numbers[] firstSet,
+            Numbers[] secondSet)
+        {
+            // Arrange
+            // Act
+            // Assert
+            firstSet.Should().AllSatisfy(x => x.Should().Be(Numbers.Five));
+            secondSet.Where(x => x != Numbers.Five).Should().HaveCountGreaterThan(1);
+        }
+
+        [AutoData]
+        [Theory(DisplayName = "GIVEN multiple values specified but one WHEN values populated THEN generated sets have no common part")]
+        public void GivenDifferentValuesSpecifiedForDifferentSets_WhenValuesPopulated_ThenGeneratedSetsHaveNoCommonPart(
+            [Except(
+                Numbers.None,
+                Numbers.One,
+                Numbers.Two)] Numbers[] firstSet,
+            [Except(
+                Numbers.Three,
+                Numbers.Four,
+                Numbers.Five)] Numbers[] secondSet)
+        {
+            // Arrange
+            // Act
+            // Assert
+            firstSet.Should().AllSatisfy(x => x.Should().BeOneOf(Numbers.Three, Numbers.Four, Numbers.Five));
+            secondSet.Should().AllSatisfy(x => x.Should().BeOneOf(Numbers.None, Numbers.One, Numbers.Two));
+        }
+
+        [AutoData]
+        [Theory(DisplayName = "GIVEN values specified only for one set WHEN values populated THEN the other set is not impacted")]
+        public void GivenValuesSpecifiedForFirstValueAndFrozen_WhenValuesPopulated_ThenBothValuesAreImpacted(
+            [Frozen] [Except(
+                Numbers.None,
+                Numbers.One,
+                Numbers.Two,
+                Numbers.Three,
+                Numbers.Four)] Numbers firstValue,
+            Numbers secondValue)
+        {
+            // Arrange
+            // Act
+            // Assert
+            firstValue.Should().Be(Numbers.Five);
+            secondValue.Should().Be(firstValue);
+        }
+    }
+}