From afd89d6032ca8b73bcea7100bed0313b082a8d6b Mon Sep 17 00:00:00 2001 From: MCKanpolat Date: Mon, 5 Mar 2018 16:44:28 +0300 Subject: [PATCH] StubGeneratorDefaultValueAttribute and StubGeneratorIgnoreAttribute are added. Some memory optimization --- .../DefaultValueTestModel.cs | 30 +++++ .../ModelWithComplexTypeProperty.cs | 5 + .../StubGenerator.Test.Models.csproj | 4 + src/StubGenerator.Test/CacheManagerTests.cs | 14 +-- src/StubGenerator.Test/StubManagerTests.cs | 110 +++++++++++++++++- .../StubGeneratorDefaultValueAttribute.cs | 17 +++ .../StubGeneratorIgnoreAttribute.cs | 10 ++ .../{ => Core}/Constants.cs | 0 .../Core/FakeDataFactory.cs | 20 +++- .../FakeDataGenerators/BoolValueGenerator.cs | 10 +- .../FakeDataGenerators/CharValueGenerator.cs | 13 ++- .../DateTimeValueGenerator.cs | 12 +- .../DecimalValueGenerator.cs | 10 +- .../DoubleValueGenerator.cs | 10 +- .../FakeDataGenerators/EnumValueGenerator.cs | 9 +- .../FloatValueGeneratorBase.cs | 23 ++++ .../IntegerValueGeneratorBase.cs | 16 ++- .../UInt32ValueGenerator.cs | 21 ++++ 18 files changed, 295 insertions(+), 39 deletions(-) create mode 100644 src/StubGenerator.Test.Models/DefaultValueTestModel.cs create mode 100644 src/StubMiddleware.Core/Core/Attributes/StubGeneratorDefaultValueAttribute.cs create mode 100644 src/StubMiddleware.Core/Core/Attributes/StubGeneratorIgnoreAttribute.cs rename src/StubMiddleware.Core/{ => Core}/Constants.cs (100%) create mode 100644 src/StubMiddleware.Core/Core/FakeDataGenerators/FloatValueGeneratorBase.cs create mode 100644 src/StubMiddleware.Core/Core/FakeDataGenerators/UInt32ValueGenerator.cs diff --git a/src/StubGenerator.Test.Models/DefaultValueTestModel.cs b/src/StubGenerator.Test.Models/DefaultValueTestModel.cs new file mode 100644 index 0000000..88547d7 --- /dev/null +++ b/src/StubGenerator.Test.Models/DefaultValueTestModel.cs @@ -0,0 +1,30 @@ +using StubGenerator.Core; +using StubGenerator.Core.Attributes; + +namespace StubGenerator.Test.Models +{ + public class DefaultValueTestModel + { + public const string defaultEmail = "default@default.com"; + public const EnTestEnum defaultEnum = EnTestEnum.Option2; + public const int defaultInt = 123456; + + + public string FirstName { get; set; } + public string LastName { get; set; } + [StubGeneratorDefaultValue(defaultEmail)] + public string Email { get; set; } + + [StubGeneratorDefaultValue(defaultEnum)] + public EnTestEnum TestEnum { get; set; } + + [StubGeneratorDefaultValue(defaultInt)] + public int TestInt { get; set; } + + [StubGeneratorIgnore] + public int TestIntIgnored { get; set; } + + [StubGeneratorIgnore] + public string Country { get; set; } + } +} diff --git a/src/StubGenerator.Test.Models/ModelWithComplexTypeProperty.cs b/src/StubGenerator.Test.Models/ModelWithComplexTypeProperty.cs index 0dfd21c..f9b9dc1 100644 --- a/src/StubGenerator.Test.Models/ModelWithComplexTypeProperty.cs +++ b/src/StubGenerator.Test.Models/ModelWithComplexTypeProperty.cs @@ -77,4 +77,9 @@ public ModelConstructorMixed(string firstName) public string FirstName { get; set; } } + + public class ModelOfType where T : struct + { + public T Value { get; set; } + } } diff --git a/src/StubGenerator.Test.Models/StubGenerator.Test.Models.csproj b/src/StubGenerator.Test.Models/StubGenerator.Test.Models.csproj index 5766db6..5b41cde 100644 --- a/src/StubGenerator.Test.Models/StubGenerator.Test.Models.csproj +++ b/src/StubGenerator.Test.Models/StubGenerator.Test.Models.csproj @@ -4,4 +4,8 @@ netcoreapp2.0 + + + + diff --git a/src/StubGenerator.Test/CacheManagerTests.cs b/src/StubGenerator.Test/CacheManagerTests.cs index 3fe64a6..658a5a9 100644 --- a/src/StubGenerator.Test/CacheManagerTests.cs +++ b/src/StubGenerator.Test/CacheManagerTests.cs @@ -16,8 +16,8 @@ public CacheManagerTests() _stubTypeMemoryCache = new MemoryStubTypeCache(_cacheKeyGenerator); } - [Fact(DisplayName = "Cache Key Generator Test")] - public void CacheKeyGeneratorTest() + [Fact(DisplayName = "Should Generate Cache Key")] + public void Should_Generate_Cache_Key() { var cacheKey = _cacheKeyGenerator.GenerateKey(); Assert.NotEmpty(cacheKey); @@ -32,9 +32,8 @@ public void Should_Add_PropertyInfos_To_Cache_Successfully() Assert.Equal(cachedPropertyInfos.Length, personData.GetType().GetProperties().Length); } - - [Fact(DisplayName = "Ensure Memory Cache Manager Empty")] - public void CacheManagerEmptyTest() + [Fact(DisplayName = "Should Memory Cache Is Empty")] + public void Should_Memory_Cache_Is_Empty() { var personData = new PersonDto(); _stubTypeMemoryCache.Set(personData, personData.GetType().GetProperties()); @@ -42,9 +41,8 @@ public void CacheManagerEmptyTest() Assert.True(_stubTypeMemoryCache.IsEmpty()); } - - [Fact(DisplayName = "Memory Cache Manager Concurrency")] - public void CacheManagerConcurrencyTest() + [Fact(DisplayName = "Should Cache Manager Is Concurrent")] + public void Should_Cache_Manager_Is_Concurrent() { var personData = new PersonDto(); var mainTask = Task.Run(async () => diff --git a/src/StubGenerator.Test/StubManagerTests.cs b/src/StubGenerator.Test/StubManagerTests.cs index 4d99b3a..3323121 100644 --- a/src/StubGenerator.Test/StubManagerTests.cs +++ b/src/StubGenerator.Test/StubManagerTests.cs @@ -69,6 +69,90 @@ public void Should_Generate_Data_For_Guid_Type() Assert.True(Guid.TryParse(generatedStubData.GuidProperty.ToString(), out _)); } + + [Fact(DisplayName = "Should Generate Data For Byte Type In Range")] + public void Should_Generate_Data_For_Byte_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, byte.MinValue, byte.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For Single Type In Range")] + public void Should_Generate_Data_For_Single_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Single.MinValue, Single.MaxValue); + } + + + [Fact(DisplayName = "Should Generate Data For Int16 Type In Range")] + public void Should_Generate_Data_For_Int16_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Int16.MinValue, Int16.MaxValue); + } + + + [Fact(DisplayName = "Should Generate Data For Int32 Type In Range")] + public void Should_Generate_Data_For_Int32_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Int32.MinValue, Int32.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For Int64 Type In Range")] + public void Should_Generate_Data_For_Int64_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Int64.MinValue, Int64.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For Double Type In Range")] + public void Should_Generate_Data_For_Double_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Double.MinValue, Double.MaxValue); + } + + + [Fact(DisplayName = "Should Generate Data For Decimal Type In Range")] + public void Should_Generate_Data_For_Decimal_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, Decimal.MinValue, Decimal.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For UInt16 Type In Range")] + public void Should_Generate_Data_For_UInt16_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, UInt16.MinValue, UInt16.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For UInt32 Type In Range")] + public void Should_Generate_Data_For_UInt32_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, UInt32.MinValue, UInt32.MaxValue); + } + + [Fact(DisplayName = "Should Generate Data For UInt64 Type In Range")] + public void Should_Generate_Data_For_UInt64_Type_In_Range() + { + var generatedStubData = _stubManager.CreateNew>(); + Assert.NotNull(generatedStubData); + Assert.InRange(generatedStubData.Value, UInt64.MinValue, UInt64.MaxValue); + } + [Fact(DisplayName = "Should Generate Data For Char Type")] public void Should_Generate_Data_For_Chard_Type() { @@ -135,7 +219,7 @@ public void Should_Generate_Data_For_Collection_Types() Assert.True(generatedStubData.CollectionTypeComplex[0].IntegerProperty != default(int)); } - [Fact(DisplayName = "Should Set Given values while generating data")] + [Fact(DisplayName = "Should Set Given Values While Generating Data")] public void Should_Set_Given_Values_While_Generating_Data() { var givenDataTime = new DateTime(2017, 1, 1); @@ -157,8 +241,8 @@ public void Should_Generate_Data_For_Complex_Type_Properties_Check_Parameterless } - [Fact(DisplayName = "Check Unsupported Types")] - public void Check_Unsupported_Types() + [Fact(DisplayName = "Should Unsupported Types Are Null")] + public void Should_Unsupported_Types_Are_Null() { var generatedStubData = _stubManager.CreateNew(); Assert.NotNull(generatedStubData); @@ -194,5 +278,25 @@ public void Should_Generate_Generic_Class_With_2_Argument_Count_Specified() var generatedStubData = _stubManager.InvokeCreateNew("StubGenerator.Test.Models.GenericModel`2, StubGenerator.Test.Models"); Assert.NotNull(generatedStubData); } + + + [Fact(DisplayName = "Should Set Given Value Property Has Default Value Attribute")] + public void Should_Set_Given_Value_Property_Has_Default_Value_Attribute() + { + var generatedStubData = _stubManager.CreateNew(); + Assert.NotNull(generatedStubData); + Assert.Equal(DefaultValueTestModel.defaultEmail, generatedStubData.Email); + Assert.Equal(DefaultValueTestModel.defaultEnum, generatedStubData.TestEnum); + Assert.Equal(DefaultValueTestModel.defaultInt, generatedStubData.TestInt); + } + + + [Fact(DisplayName = "Should Set Null Value If Property Has Ignore Attribute")] + public void Should_Set_Null_Value_If_Property_Has_Ignore_Attribute() + { + var generatedStubData = _stubManager.CreateNew(); + Assert.NotNull(generatedStubData); + Assert.Null(generatedStubData.Country); + } } } diff --git a/src/StubMiddleware.Core/Core/Attributes/StubGeneratorDefaultValueAttribute.cs b/src/StubMiddleware.Core/Core/Attributes/StubGeneratorDefaultValueAttribute.cs new file mode 100644 index 0000000..14b6978 --- /dev/null +++ b/src/StubMiddleware.Core/Core/Attributes/StubGeneratorDefaultValueAttribute.cs @@ -0,0 +1,17 @@ +using System; + +namespace StubGenerator.Core.Attributes +{ + [AttributeUsage(AttributeTargets.Property)] + public sealed class StubGeneratorDefaultValueAttribute : Attribute + { + private object _defaultValue; + + public StubGeneratorDefaultValueAttribute(object defaultValue) + { + DefaultValue = defaultValue; + } + + public object DefaultValue { get => _defaultValue; private set => _defaultValue = value; } + } +} diff --git a/src/StubMiddleware.Core/Core/Attributes/StubGeneratorIgnoreAttribute.cs b/src/StubMiddleware.Core/Core/Attributes/StubGeneratorIgnoreAttribute.cs new file mode 100644 index 0000000..7289cfa --- /dev/null +++ b/src/StubMiddleware.Core/Core/Attributes/StubGeneratorIgnoreAttribute.cs @@ -0,0 +1,10 @@ +using System; + +namespace StubGenerator.Core.Attributes +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)] + public sealed class StubGeneratorIgnoreAttribute : Attribute + { + + } +} diff --git a/src/StubMiddleware.Core/Constants.cs b/src/StubMiddleware.Core/Core/Constants.cs similarity index 100% rename from src/StubMiddleware.Core/Constants.cs rename to src/StubMiddleware.Core/Core/Constants.cs diff --git a/src/StubMiddleware.Core/Core/FakeDataFactory.cs b/src/StubMiddleware.Core/Core/FakeDataFactory.cs index 3c75968..46a1bec 100644 --- a/src/StubMiddleware.Core/Core/FakeDataFactory.cs +++ b/src/StubMiddleware.Core/Core/FakeDataFactory.cs @@ -5,6 +5,7 @@ using StubGenerator.Defaults; using System.Linq; using StubGenerator.Core.FakeDataGenerators; +using StubGenerator.Core.Attributes; namespace StubGenerator.Core.FakeDataProvider { @@ -29,6 +30,17 @@ public object ProvideValue(PropertyInfo propertyInfo) return null; } + if (propertyInfo.GetCustomAttribute() != null) + { + return null; + } + + var stubGeneratorDefaultValueAttribute = propertyInfo.GetCustomAttribute(); + if (stubGeneratorDefaultValueAttribute != null) + { + return stubGeneratorDefaultValueAttribute.DefaultValue; + } + var matchingConvetion = _stubDataMappingProfile.Conventions.FirstOrDefault(c => c.Condition(propertyInfo)); if (matchingConvetion != null) { @@ -64,15 +76,15 @@ private static object GenerateValueByType(Type propertyType) case TypeCode.Int32: return new IntegerValueGeneratorBase().Generate(); case TypeCode.Int64: - return new IntegerValueGeneratorBase().Generate(); + return new FloatValueGeneratorBase().Generate(); case TypeCode.UInt16: return new IntegerValueGeneratorBase().Generate(); case TypeCode.UInt32: - return new IntegerValueGeneratorBase().Generate(); + return new UInt32ValueGenerator().Generate(); case TypeCode.UInt64: - return new IntegerValueGeneratorBase().Generate(); + return new FloatValueGeneratorBase().Generate(); case TypeCode.Single: - return new IntegerValueGeneratorBase().Generate(); + return new FloatValueGeneratorBase().Generate(); case TypeCode.Byte: return new IntegerValueGeneratorBase().Generate(); case TypeCode.Double: diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/BoolValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/BoolValueGenerator.cs index 44e719a..e2f937b 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/BoolValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/BoolValueGenerator.cs @@ -4,11 +4,15 @@ namespace StubGenerator.Core.FakeDataGenerators { public class BoolValueGenerator : IValueGenerator { - private static readonly Random _random; - static BoolValueGenerator() => _random = new Random(); + private static readonly Lazy _random; + static BoolValueGenerator() + { + _random = new Lazy(() => new Random()); + } + public object Generate() { - return _random.NextDouble() >= 0.5; + return _random.Value.NextDouble() >= 0.5; } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/CharValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/CharValueGenerator.cs index a01cf0e..e9626bb 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/CharValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/CharValueGenerator.cs @@ -4,16 +4,19 @@ namespace StubGenerator.Core.FakeDataGenerators { public class CharValueGenerator : IValueGenerator { - private static char[] charValues; - private static int charsize; + private static readonly Lazy _random; + private static char[] _charValues; + private static int _charsize; static CharValueGenerator() { - charValues = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray(); - charsize = charValues.Length; + _random = new Lazy(() => new Random()); + _charValues = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray(); + _charsize = _charValues.Length; } + public object Generate() { - return charValues[new Random().Next(0, charsize - 1)]; + return _charValues[_random.Value.Next(0, _charsize - 1)]; } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/DateTimeValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/DateTimeValueGenerator.cs index f7ce10d..b23c878 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/DateTimeValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/DateTimeValueGenerator.cs @@ -4,12 +4,16 @@ namespace StubGenerator.Core.FakeDataGenerators { public class DateTimeValueGenerator : IValueGenerator { - private static readonly Random _random; - static DateTimeValueGenerator() => _random = new Random(); + private static readonly Lazy _random; + static DateTimeValueGenerator() + { + _random = new Lazy(() => new Random()); + } + public object Generate() { - var startDate = new DateTime(1995, 1, 1); - return startDate.AddDays(_random.Next(0, (DateTime.Today - startDate).Days)); + var startDate = new DateTime(1900, 1, 1); + return startDate.AddDays(_random.Value.Next(0, (DateTime.Today - startDate).Days)); } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/DecimalValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/DecimalValueGenerator.cs index 9d158ba..7ed700d 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/DecimalValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/DecimalValueGenerator.cs @@ -5,11 +5,15 @@ namespace StubGenerator.Core.FakeDataGenerators { public class DecimalValueGenerator : IValueGenerator { - private static readonly Random _random; - static DecimalValueGenerator() => _random = new Random(); + private static readonly Lazy _random; + static DecimalValueGenerator() + { + _random = new Lazy(() => new Random()); + } + public object Generate() { - return _random.NextDecimal(); + return _random.Value.NextDecimal(); } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/DoubleValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/DoubleValueGenerator.cs index 1459b52..32caa67 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/DoubleValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/DoubleValueGenerator.cs @@ -1,14 +1,18 @@ using System; + namespace StubGenerator.Core.FakeDataGenerators { public class DoubleValueGenerator : IValueGenerator { - private static readonly Random _random; - static DoubleValueGenerator() => _random = new Random(); + private static readonly Lazy _random; + static DoubleValueGenerator() + { + _random = new Lazy(() => new Random()); + } public object Generate() { - return _random.NextDouble(); + return _random.Value.NextDouble(); } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/EnumValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/EnumValueGenerator.cs index 6e7f5cc..32754c1 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/EnumValueGenerator.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/EnumValueGenerator.cs @@ -6,8 +6,11 @@ public class EnumValueGenerator : IValueGenerator { private readonly Type _enumType; - private static readonly Random _random; - static EnumValueGenerator() => _random = new Random(); + private static readonly Lazy _random; + static EnumValueGenerator() + { + _random = new Lazy(() => new Random()); + } public EnumValueGenerator(Type enumType) { @@ -17,7 +20,7 @@ public EnumValueGenerator(Type enumType) public object Generate() { var values = Enum.GetValues(_enumType); - return values.GetValue(_random.Next(values.Length)); + return values.GetValue(_random.Value.Next(values.Length)); } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/FloatValueGeneratorBase.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/FloatValueGeneratorBase.cs new file mode 100644 index 0000000..940b732 --- /dev/null +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/FloatValueGeneratorBase.cs @@ -0,0 +1,23 @@ +using System; +using System.Threading; + +namespace StubGenerator.Core.FakeDataGenerators +{ + public class FloatValueGeneratorBase : IValueGenerator where T : struct + { +#pragma warning disable S2743 // Static fields should not be used in generic types + private static readonly Lazy _random; +#pragma warning restore S2743 // Static fields should not be used in generic types + + static FloatValueGeneratorBase() + { + _random = new Lazy(() => new Random()); + } + + public object Generate() + { + object randomValue = (long)(_random.Value.NextDouble() * Int64.MaxValue); + return Convert.ChangeType(randomValue, typeof(T)); + } + } +} diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/IntegerValueGeneratorBase.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/IntegerValueGeneratorBase.cs index cb5b602..794c25d 100644 --- a/src/StubMiddleware.Core/Core/FakeDataGenerators/IntegerValueGeneratorBase.cs +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/IntegerValueGeneratorBase.cs @@ -4,11 +4,21 @@ namespace StubGenerator.Core.FakeDataGenerators { public class IntegerValueGeneratorBase : IValueGenerator where T : struct { +#pragma warning disable S2743 // Static fields should not be used in generic types + private static readonly Lazy _random; +#pragma warning restore S2743 // Static fields should not be used in generic types + + static IntegerValueGeneratorBase() + { + _random = new Lazy(() => new Random()); + } + public object Generate() { - var maxValue = (int)typeof(T).GetField("MaxValue").GetValue(null); - var minValue = (int)typeof(T).GetField("MinValue").GetValue(null); - return new Random().Next(minValue, maxValue); + var maxValue = Convert.ToInt32(Convert.ChangeType(typeof(T).GetField("MaxValue").GetValue(null), typeof(T))); + var minValue = Convert.ToInt32(Convert.ChangeType(typeof(T).GetField("MinValue").GetValue(null), typeof(T))); + var randomValue = _random.Value.Next(minValue, maxValue); + return Convert.ChangeType(randomValue, typeof(T)); } } } diff --git a/src/StubMiddleware.Core/Core/FakeDataGenerators/UInt32ValueGenerator.cs b/src/StubMiddleware.Core/Core/FakeDataGenerators/UInt32ValueGenerator.cs new file mode 100644 index 0000000..f3e48f3 --- /dev/null +++ b/src/StubMiddleware.Core/Core/FakeDataGenerators/UInt32ValueGenerator.cs @@ -0,0 +1,21 @@ +using System; + +namespace StubGenerator.Core.FakeDataGenerators +{ + public class UInt32ValueGenerator : IValueGenerator + { + private static readonly Lazy _random; + + static UInt32ValueGenerator() + { + _random = new Lazy(() => new Random()); + } + + public object Generate() + { + uint thirtyBits = (uint)_random.Value.Next(1 << 30); + uint twoBits = (uint)_random.Value.Next(1 << 2); + return (thirtyBits << 2) | twoBits; + } + } +}