Merge pull request #10 from robdmoore/integer-equivalence-classes

Added integer equivalence classes

Author: robdmoore

NTestDataBuilder.Tests/EquivalenceClasses/IntegerEquivalenceClassesTests.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.EquivalenceClasses;
+using Shouldly;
+using Xunit;
+
+namespace NTestDataBuilder.Tests.EquivalenceClasses
+{
+    public class IntegerEquivalenceClassesTests
+    {
+        public AnonymousValueFixture Any { get; private set; }
+
+        public IntegerEquivalenceClassesTests()
+        {
+            Any = new AnonymousValueFixture();
+        }
+
+        [Fact]
+        public void WhenGettingAnyPositiveInteger_ThenReturnDifferentPositiveIntegersEveryTime()
+        {
+            var s1 = Any.PositiveInteger();
+            var s2 = Any.PositiveInteger();
+
+            s1.ShouldBeOfType<int>();
+            s2.ShouldBeOfType<int>();
+            s1.ShouldBeGreaterThan(0);
+            s2.ShouldBeGreaterThan(0);
+            s1.ShouldNotBe(s2);
+        }
+
+        [Fact]
+        public void WhenGettingAnyNegativeInteger_ThenReturnDifferentNegativeIntegersEveryTime()
+        {
+            var s1 = Any.NegativeInteger();
+            var s2 = Any.NegativeInteger();
+
+            s1.ShouldBeOfType<int>();
+            s2.ShouldBeOfType<int>();
+            s1.ShouldBeLessThan(0);
+            s2.ShouldBeLessThan(0);
+            s1.ShouldNotBe(s2);
+        }
+
+        [Fact]
+        public void WhenGettingAnyIntegerExceptASetOfIntegers_ThenReturnDifferentIntegersExceptTheGivenIntegersEveryTime()
+        {
+            var generated = new List<int>();
+
+            for (var i = 0; i < 1000; i++)
+            {
+                var integer = Any.IntegerExcept(1, 5, 200, 356, 4, 53);
+                generated.Add(integer);
+            }
+
+            generated.ShouldAllBe(i => i != 1
+                && i != 5
+                && i != 200
+                && i != 356
+                && i != 4
+                && i != 53);
+            generated.Distinct().Count()
+                .ShouldBe(generated.Count);
+        }
+    }
+}

NTestDataBuilder.Tests/NTestDataBuilder.Tests.csproj

@@ -61,6 +61,7 @@
     <Compile Include="DataSources\Generators\SequentiaGeneratorTests.cs" />
     <Compile Include="DataSources\DataSourceConventionTests.cs" />
     <Compile Include="EquivalenceClasses\DictionaryEquivalenceClassesTests.cs" />
+    <Compile Include="EquivalenceClasses\IntegerEquivalenceClassesTests.cs" />
     <Compile Include="EquivalenceClasses\StringEquivalenceClassesTests.cs" />
     <Compile Include="AsProxyTests.cs" />
     <Compile Include="BuildListTests.cs" />

NTestDataBuilder/EquivalenceClasses/IntegerEquivalenceClasses.cs

@@ -0,0 +1,49 @@
+using System.Linq;
+using System.Runtime.CompilerServices;
+using NSubstitute.Routing.Handlers;
+using Ploeh.AutoFixture;
+
+namespace NTestDataBuilder.EquivalenceClasses
+{
+    /// <summary>
+    /// Extension methods that describe equivalence classes for generating anonymous integer values.
+    /// </summary>
+    public static class IntegerEquivalenceClasses
+    {
+        /// <summary>
+        /// Generate and return a positive integer.
+        /// </summary>
+        /// <param name="fixture">The fixture to generate an integer for</param>
+        /// <returns>The generated integer</returns>
+        public static int PositiveInteger(this AnonymousValueFixture fixture)
+        {
+            return fixture.Fixture.Create<int>();
+        }
+
+        /// <summary>
+        /// Generate and return a negative integer.
+        /// </summary>
+        /// <param name="fixture">The fixture to generate an integer for</param>
+        /// <returns>The generated integer</returns>
+        public static int NegativeInteger(this AnonymousValueFixture fixture)
+        {
+            return 0 - fixture.PositiveInteger();
+        }
+
+        /// <summary>
+        /// Generate and return an integer except for the passed in integer(s).
+        /// </summary>
+        /// <param name="fixture">The fixture to generate an integer for</param>
+        /// <param name="exceptFor">A list of integers to not return</param>
+        /// <returns>The generated integer</returns>
+        public static int IntegerExcept(this AnonymousValueFixture fixture, params int[] exceptFor)
+        {
+            int result;
+            do
+            {
+                result = fixture.PositiveInteger();
+            } while (exceptFor.Contains(result));
+            return result;
+        }
+    }
+}

NTestDataBuilder/NTestDataBuilder.csproj

@@ -76,6 +76,7 @@
     <Compile Include="DataSources\Person\PersonNameTitleSource.cs" />
     <Compile Include="DummyContext.cs" />
     <Compile Include="EquivalenceClasses\GeographyEquivalenceClassescs.cs" />
+    <Compile Include="EquivalenceClasses\IntegerEquivalenceClasses.cs" />
     <Compile Include="EquivalenceClasses\PersonEquivalenceClasses.cs" />
     <Compile Include="DataSources\Generators\IGenerator.cs" />
     <Compile Include="DataSources\Generators\RandomGenerator.cs" />