public void ShouldBeAbleToUseADateTime()
{
var generator = new SequentialGenerator <DateTime>();
generator.Generate().ShouldBe(DateTime.MinValue);
generator.Generate().ShouldBe(DateTime.MinValue.AddDays(1));
}
public void GenerateRange()
{
var xkcdPages = new string[5];
xkcdPages [0] = "http://xkcd.com/610";
xkcdPages [1] = "http://xkcd.com/611";
xkcdPages [2] = "http://xkcd.com/612";
xkcdPages [3] = "http://xkcd.com/613";
xkcdPages [4] = "http://xkcd.com/614";
var comic = new ComicUri("http://xkcd.com/614");
var xkcdRules = new SequentialGenerator(comic);
Assert.AreEqual(xkcdPages, xkcdRules.Generate(Enumerable.Range(610, 5)));
xkcdPages = new string[5];
xkcdPages [0] = "http://xkcd.com/1";
xkcdPages [1] = "http://xkcd.com/2";
xkcdPages [2] = "http://xkcd.com/3";
xkcdPages [3] = "http://xkcd.com/4";
xkcdPages [4] = "http://xkcd.com/5";
comic = new ComicUri("http://xkcd.com/614");
xkcdRules = new SequentialGenerator(comic);
Assert.AreEqual(xkcdPages, xkcdRules.Generate(Enumerable.Range(1, 5)));
xkcdPages = new string[5];
xkcdPages [0] = "http://xkcd.com/001";
xkcdPages [1] = "http://xkcd.com/002";
xkcdPages [2] = "http://xkcd.com/003";
xkcdPages [3] = "http://xkcd.com/004";
xkcdPages [4] = "http://xkcd.com/005";
comic = new ComicUri("http://xkcd.com/614");
xkcdRules = new SequentialGenerator(comic);
xkcdRules.Padded = true;
Assert.AreEqual(xkcdPages, xkcdRules.Generate(Enumerable.Range(1, 5)));
}
public void ShouldBeAbleToUseADateTime()
{
var generator = new SequentialGenerator <DateTime>();
Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue));
Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue.AddDays(1)));
}
private IEnumerable <Address> MakeFifteenThousandAddress(bool generateIncrementalId)
{
if (generateIncrementalId)
{
var generator = new SequentialGenerator <int>();
generator.StartingWith(nextValueToGenerate: 4);
return(Builder <Address> .CreateListOfSize(15_000)
.All()
.With(a => a.Id = GetId(generator))
.With(a => a.Street = "Updated Street")
.With(a => a.ZipPostCode = GetZipCode())
.With(a => a.City = GetCity())
.Build());
}
return(Builder <Address> .CreateListOfSize(15_000)
.All()
.With(a => a.Id = 0)
.With(a => a.Street = GetStreet())
.With(a => a.ZipPostCode = GetZipCode())
.With(a => a.City = GetCity())
.Build());
}
public void GenerateSome()
{
var xkcdPages = new string[7];
xkcdPages [0] = "http://xkcd.com/608";
xkcdPages [1] = "http://xkcd.com/609";
xkcdPages [2] = "http://xkcd.com/610";
xkcdPages [3] = "http://xkcd.com/611";
xkcdPages [4] = "http://xkcd.com/612";
xkcdPages [5] = "http://xkcd.com/613";
xkcdPages [6] = "http://xkcd.com/614";
var comic = new ComicUri("http://xkcd.com/608");
var seqCount = new SequentialGenerator(comic);
Assert.AreEqual(xkcdPages, seqCount.GenerateSome());
xkcdPages = new string[7];
xkcdPages [0] = "http://xkcd.com/3";
xkcdPages [1] = "http://xkcd.com/4";
xkcdPages [2] = "http://xkcd.com/5";
xkcdPages [3] = "http://xkcd.com/6";
xkcdPages [4] = "http://xkcd.com/7";
xkcdPages [5] = "http://xkcd.com/8";
xkcdPages [6] = "http://xkcd.com/9";
comic = new ComicUri("http://xkcd.com/5");
seqCount = new SequentialGenerator(comic);
Assert.AreEqual(xkcdPages, seqCount.GenerateSome());
}
public void UsingSequentialGenerators()
{
// Arrange
var decimalGenerator = new SequentialGenerator <decimal>
{
Increment = 10,
Direction = GeneratorDirection.Descending
};
decimalGenerator.StartingWith(2000);
var intGenerator = new SequentialGenerator <int>
{
Increment = 10000
};
// Act
var list = new Builder()
.CreateListOfSize <Product>(3)
.All()
.With(x => x.PriceBeforeTax = decimalGenerator.Generate())
.And(x => x.Id = intGenerator.Generate())
.Build();
// Assert
list[0].PriceBeforeTax.ShouldBe(2000);
list[1].PriceBeforeTax.ShouldBe(1990);
list[2].PriceBeforeTax.ShouldBe(1980);
list[0].Id.ShouldBe(0);
list[1].Id.ShouldBe(10000);
list[2].Id.ShouldBe(20000);
}
public void UsingSequentialGenerators()
{
var builderSetup = new BuilderSettings();
// Arrange
var decimalGenerator = new SequentialGenerator <decimal>
{
Increment = 10,
Direction = GeneratorDirection.Descending
};
decimalGenerator.StartingWith(2000);
var intGenerator = new SequentialGenerator <int> {
Increment = 10000
};
// Act
var list = new Builder(builderSetup).CreateListOfSize <Product>(3)
.All()
.With(x => x.PriceBeforeTax = decimalGenerator.Generate())
.And(x => x.Id = intGenerator.Generate())
.Build();
// Assert
Assert.That(list[0].PriceBeforeTax, Is.EqualTo(2000));
Assert.That(list[1].PriceBeforeTax, Is.EqualTo(1990));
Assert.That(list[2].PriceBeforeTax, Is.EqualTo(1980));
Assert.That(list[0].Id, Is.EqualTo(0));
Assert.That(list[1].Id, Is.EqualTo(10000));
Assert.That(list[2].Id, Is.EqualTo(20000));
}
async Task GivenGroupsInDatabase()
{
using (var dbContext = new WordkiDbContext(ConnectionStringProvider))
{
var user = Builder <Api.Domain.User> .CreateNew()
.With(u => u.Id = 1)
.With(u => u.Name = "user")
.With(u => u.Password = Host.EncrypterMock.Object.Md5Hash("pass"))
.With(u => u.LastLoginDate = new DateTime(2020, 1, 1))
.With(u => u.CreationDate = new DateTime(2020, 1, 1))
.Build();
dbContext.Users.Add(user);
var sequence = new SequentialGenerator <long> {
Direction = GeneratorDirection.Ascending, Increment = 1
};
sequence.StartingWith(1);
var builder = Builder <Api.Domain.Group> .CreateNew()
.With(g => g.Id = sequence.Generate())
.With(g => g.GroupLanguage1 = 1)
.With(g => g.GroupLanguage2 = 2)
.With(g => g.Name = "name");
var groups = new Api.Domain.Group[] { builder.Build(), builder.Build() };
dbContext.Groups.AddRange(groups);
await dbContext.SaveChangesAsync();
}
}
public void ShouldBeAbleToUseABoolean()
{
var generator = new SequentialGenerator <bool>();
generator.Generate().ShouldBe(false);
generator.Generate().ShouldBe(true);
generator.Generate().ShouldBe(false);
}
internal static void InitializeUniqueEmailAddressSource()
{
var recordCount = Fixture.Words(FromDictionary.PersonEmailAddress).Data.Count;
var generator = new SequentialGenerator(0, recordCount, listShouldBeUnique: true);
_uniquePersonEmailAddressSource = new Words(generator, new CachedFileDictionaryRepository(),
FromDictionary.PersonEmailAddress);
}
public void ShouldBeAbleToUseABoolean()
{
var generator = new SequentialGenerator <bool>();
Assert.That(generator.Generate(), Is.EqualTo(false));
Assert.That(generator.Generate(), Is.EqualTo(true));
Assert.That(generator.Generate(), Is.EqualTo(false));
}
public void SetUp()
{
FakeDi.Register();
_repoUnit = new RepoUnit();
_rules = new UsersRules(_repoUnit);
_generator = new SequentialGenerator<DateTime> { Direction = GeneratorDirection.Ascending };
}
public void IdentifyImgXkcd ()
{
var url = "http://xkcd.com/614";
var xkcdRules = new SequentialGenerator (url);
var actualUrl = "http://imgs.xkcd.com/comics/woodpecker.png";
string result = null;
Assert.AreEqual (1, UrlGenerator.IdentifyImg (xkcdRules.Generate (Enumerable.Range (614, 3)), out result));
Assert.AreEqual (actualUrl, result);
}
public void ShouldBeAbleToUseAFloat()
{
var generator = new SequentialGenerator<float>();
Assert.That(generator.Generate(), Is.EqualTo(0f));
Assert.That(generator.Generate(), Is.EqualTo(1f));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0f));
Assert.That(generator.Generate(), Is.EqualTo(-1f));
}
public void WhenGeneratingIntegers_ThenShouldBeSequential()
{
var sut = new SequentialGenerator(0, 11);
for (int index = sut.StartIndex; index < sut.ListSize; index++)
{
sut.Generate().ShouldBe(index);
}
}
public void ShouldBeAbleToUseADouble()
{
var generator = new SequentialGenerator<double>();
Assert.That(generator.Generate(), Is.EqualTo(0d));
Assert.That(generator.Generate(), Is.EqualTo(1d));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0d));
Assert.That(generator.Generate(), Is.EqualTo(-1d));
}
static LocationGenerator()
{
charGenerator = new SequentialGenerator<char>();
shelfGenerator = new SequentialGenerator<int>();
locGenerator = new SequentialGenerator<int> {Increment = 1000};
charGenerator.StartingWith('A');
shelfGenerator.StartingWith(1);
locGenerator.StartingWith(7500);
}
public void ShouldBeAbleToUseAFloat()
{
var generator = new SequentialGenerator <float>();
generator.Generate().ShouldBe(0f);
generator.Generate().ShouldBe(1f);
generator.Direction = GeneratorDirection.Descending;
generator.Generate().ShouldBe(0f);
generator.Generate().ShouldBe(-1f);
}
public void IdentifyImgSmbc ()
{
string url = "http://www.smbc-comics.com/index.php?db=comics&id=614";
var smbcRules = new SequentialGenerator (url);
var actualUrl = "http://www.smbc-comics.com/comics/20061011.gif";
var actualUrl2 = "http://zs1.smbc-comics.com/comics/20061011.gif";
string result = null;
Assert.AreEqual (2, UrlGenerator.IdentifyImg (smbcRules.Generate (Enumerable.Range (614, 2)), out result));
Assert.IsTrue (result.Equals (actualUrl) || result.Equals (actualUrl2));
}
public void GivenListOfBuildersWithCustomisation_WhenBuildingObjectsImplicitly_ThenTheCustomisationShouldTakeEffect()
{
var generator = new SequentialGenerator(0, 100);
List <StudentViewModel> data = Builder <StudentViewModel> .CreateListOfSize(3)
.All().With(b => b.Set(x => x.FirstName, generator.Generate().ToString()));
data.Select(c => c.FirstName).ToArray()
.ShouldBe(new[] { "0", "1", "2" });
}
public void GivenListOfBuildersWithCustomisation_WhenCallingExtensionMethodToBuildList_ThenTheCustomisationShouldTakeEffect()
{
var generator = new SequentialGenerator <int>();
var list = CustomerBuilder.CreateListOfSize(3)
.All().With(b => b.WithFirstName(generator.Generate().ToString()));
var data = list.BuildList();
Assert.That(data.Select(c => c.FirstName), Is.EqualTo(new[] { "0", "1", "2" }));
}
public void GivenCreatingAList_WhenUsingNBuilderToChangeTheList_ThenTheChangesAreReflected()
{
var generator = new SequentialGenerator <int>();
var list = CustomerBuilder.CreateListOfSize(3)
.All().With(b => b.WithFirstName(generator.Generate().ToString()))
.Build();
Assert.That(list.Select(b => b.Get(x => x.FirstName)), Is.EqualTo(new[] { "0", "1", "2" }));
}
public void ShouldBeAbleToUseADouble()
{
var generator = new SequentialGenerator <double>();
generator.Generate().ShouldBe(0d);
generator.Generate().ShouldBe(1d);
generator.Direction = GeneratorDirection.Descending;
generator.Generate().ShouldBe(0d);
generator.Generate().ShouldBe(-1d);
}
public void GivenListOfBuildersWithCustomisation_WhenBuildingEntitiesImplicitly_ThenTheCustomisationShouldTakeEffect()
{
var generator = new SequentialGenerator(0, 100);
List <Customer> data = CustomerBuilder.CreateListOfSize(3)
.All().With(b => b.WithFirstName(generator.Generate().ToString()));
data.Select(c => c.FirstName).ToArray()
.ShouldBe(new[] { "0", "1", "2" });
}
public void ShouldBeAbleToUseADouble()
{
var generator = new SequentialGenerator <double>();
Assert.That(generator.Generate(), Is.EqualTo(0d));
Assert.That(generator.Generate(), Is.EqualTo(1d));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0d));
Assert.That(generator.Generate(), Is.EqualTo(-1d));
}
public void ShouldBeAbleToUseAFloat()
{
var generator = new SequentialGenerator <float>();
Assert.That(generator.Generate(), Is.EqualTo(0f));
Assert.That(generator.Generate(), Is.EqualTo(1f));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0f));
Assert.That(generator.Generate(), Is.EqualTo(-1f));
}
public void ShouldBeAbleToUseAnUnsignedShort()
{
var generator = new SequentialGenerator<ushort>();
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(1));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(0));
}
internal static void ResetUniqueEmailAddressSource(this AnonymousValueFixture fixture)
{
if (_personEmailAddressSource == null)
{
_personEmailAddressSource = fixture.Words(FromDictionary.PersonEmailAddress);
}
var generator = new SequentialGenerator(0, _personEmailAddressSource.Data.Count, listShouldBeUnique: true);
_uniquePersonEmailAddressSource = new Words(generator, new CachedFileDictionaryRepository(),
FromDictionary.PersonEmailAddress);
}
public void ShouldBeAbleToUseAnUnsignedInt()
{
var generator = new SequentialGenerator <uint>();
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(1));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(0));
}
public void ShouldBeAbleToUseAnUnsignedLong()
{
var generator = new SequentialGenerator <ulong>();
generator.Generate().ShouldBe((ulong)0);
generator.Generate().ShouldBe((ulong)1);
generator.Direction = GeneratorDirection.Descending;
generator.Generate().ShouldBe((ulong)0);
generator.Generate().ShouldBe((ulong)0);
}
public void GivenGeneratorIsNotUnique_WhenGeneratingIntegers_ThenShouldResetAtEndOfList()
{
var sut = new SequentialGenerator(0, 2);
for (int index = sut.StartIndex; index < sut.ListSize; index++)
{
sut.Generate().ShouldBe(index);
}
sut.Generate().ShouldBe(sut.StartIndex);
}
public void ShouldBeAbleToUseAnUnsignedInt()
{
var generator = new SequentialGenerator <uint>();
generator.Generate().ShouldBe((uint)0);
generator.Generate().ShouldBe((uint)1);
generator.Direction = GeneratorDirection.Descending;
generator.Generate().ShouldBe((uint)0);
generator.Generate().ShouldBe((uint)0);
}
public CustomProductPropertyNamer(IReflectionUtil reflectionUtil, BuilderSettings builderSettings)
: base(reflectionUtil, builderSettings)
{
aisleGenerator = new SequentialGenerator <char>();
shelfGenerator = new SequentialGenerator <int> {
Increment = 2
};
locGenerator = new SequentialGenerator <int> {
Increment = 1000
};
}
public static void SetUpClass(TestContext context)
{
var seq = new SequentialGenerator<int> { Direction = GeneratorDirection.Ascending };
var gen = new RandomGenerator();
data_users = Builder<User>
.CreateListOfSize(10)
.All()
.With(u => u.DisplayName = gen.Phrase(15))
.Build();
data_channels = Builder<Channel>
.CreateListOfSize(20)
.All()
.With(m => m.Id = seq.Generate())
.And(x => x.Name = gen.Phrase(15))
.And(x => x.AuthorId = gen.Phrase(10))
.And(x => x.Author = data_users.First())
.And(x => x.Loops = gen.Boolean())
.And(x => x.DateCreated = gen.DateTime())
.And(x => x.DateUpdated = x.DateCreated + new TimeSpan(3, 0, 0))
.Random(10)
.With(x => x.DateDeactivated = x.DateUpdated + new TimeSpan(3, 0, 0))
.Build();
data_musics = Builder<Music>
.CreateListOfSize(50)
.All()
.With(m => m.Id = seq.Generate())
.And(m => m.LengthInMilliseconds = gen.Int())
.And(m => m.SizeInBytes = gen.Int())
.And(m => m.DateCreated = gen.DateTime())
.And(m => m.DateUpdated = m.DateCreated + new TimeSpan(3, 0, 0))
.Build();
channels = new Mock<ChannelService>(null);
musics = new Mock<MusicService>(null);
channels
.Setup(x => x.All())
.ReturnsAsync(data_channels);
channels
.Setup(x => x.Paginate(0, 10))
.ReturnsAsync(data_channels.Take(10).ToList());
channels
.Setup(x => x.ActiveChannels(0, 4))
.ReturnsAsync(data_channels.Take(4).ToList());
channels
.Setup(c => c.Deactivate(It.IsAny<Channel>()))
.ReturnsAsync(1);
}
public void ShouldBeAbleToUseALong()
{
var generator = new SequentialGenerator<long>();
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(1));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(-1));
}
static LocationGenerator()
{
charGenerator = new SequentialGenerator <char>();
shelfGenerator = new SequentialGenerator <int>();
locGenerator = new SequentialGenerator <int> {
Increment = 1000
};
charGenerator.StartingWith('A');
shelfGenerator.StartingWith(1);
locGenerator.StartingWith(7500);
}
public void ShouldBeAbleToUseALong()
{
var generator = new SequentialGenerator <long>();
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(1));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0));
Assert.That(generator.Generate(), Is.EqualTo(-1));
}
public void ShouldBeAbleToUseADecimal()
{
var generator = new SequentialGenerator<decimal> { Increment = .5m };
Assert.That(generator.Generate(), Is.EqualTo(0m));
Assert.That(generator.Generate(), Is.EqualTo(0.5m));
Assert.That(generator.Generate(), Is.EqualTo(1m));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo(0.5m));
Assert.That(generator.Generate(), Is.EqualTo(0m));
}
public IList<Department> GenerateDepartments(int requiredNumber)
{
SequentialGenerator<int> sequentialGenerator = new SequentialGenerator<int>
{
Direction = GeneratorDirection.Ascending,
Increment = 1
};
sequentialGenerator.StartingWith(1);
IList<Department> departments =
Builder<Department>.CreateListOfSize(requiredNumber).All().With(
x => x.DepartmentNumber = string.Concat("P", sequentialGenerator.Generate())).Build();
return departments;
}
public void RangeDeclarationsShouldExecuteInOrderOfStartingPosition()
{
var generator = new SequentialGenerator<int>();
var build = Builder<TestClass>
.CreateListOfSize(10)
.All()
.Do(x => x.Property = "item")
.TheFirst(2)
.Do(x => x.Property += String.Format("{0}{1}", generator.Generate(), generator.Generate()))
.TheNext(6)
.Do(x => x.Property += generator.Generate())
.Build();
var expected = new[]{"item01", "item23", "item4", "item5", "item6", "item7", "item8", "item9", "item", "item"};
var actual = build.Select(row => row.Property).ToArray();
Assert.That(actual, Is.EquivalentTo(expected), string.Join(", ", expected));
}
public ValuesFactory(IKeyGenerator<Guid> keyGenerator)
{
if (keyGenerator == null) throw new ArgumentNullException(nameof(keyGenerator));
this.keyGenerator = keyGenerator;
rndGenerator = new RandomGenerator();
dateTimeGenerator = new SequentialGenerator<DateTime>
{
IncrementDateBy = Pick<IncrementDate>.RandomItemFrom(new[]
{
IncrementDate.Second,
IncrementDate.Minute,
IncrementDate.Hour,
IncrementDate.Day,
IncrementDate.Month,
IncrementDate.Year,
}),
Direction = GeneratorDirection.Ascending
};
}
public void Generate_DefaultSetUp_IncrementsFromMinDateTimeValue()
{
generator = new SequentialGenerator<DateTime>();
Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue));
}
public void SetUp()
{
generator = new SequentialGenerator<DateTime>();
startingValue = new DateTime(9, 9, 9, 9, 9, 9, 9);
generator.StartingWith(startingValue);
}
public void SetUp()
{
generator = new SequentialGenerator<int>();
}
public void ShouldBeAbleToUseADateTime()
{
var generator = new SequentialGenerator<DateTime>();
Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue));
Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue.AddDays(1)));
}
public void ShouldBeAbleToUseABoolean()
{
var generator = new SequentialGenerator<bool>();
Assert.That(generator.Generate(), Is.EqualTo(false));
Assert.That(generator.Generate(), Is.EqualTo(true));
Assert.That(generator.Generate(), Is.EqualTo(false));
}
public void ShouldBeAbleToUseAChar()
{
var generator = new SequentialGenerator<char>();
generator.StartingWith('A');
Assert.That(generator.Generate(), Is.EqualTo('A'));
Assert.That(generator.Generate(), Is.EqualTo('B'));
Assert.That(generator.Generate(), Is.EqualTo('C'));
generator.Direction = GeneratorDirection.Descending;
Assert.That(generator.Generate(), Is.EqualTo('B'));
Assert.That(generator.Generate(), Is.EqualTo('A'));
}
public void UsingTheSequentialGenerator()
{
var generator = new SequentialGenerator<int> { Direction = GeneratorDirection.Descending, Increment = 2 };
generator.StartingWith(6);
var products = Builder<Product>
.CreateListOfSize(3)
.All()
.With(x => x.Id = generator.Generate())
.Build();
Assert.That(products[0].Id, Is.EqualTo(6));
Assert.That(products[1].Id, Is.EqualTo(4));
Assert.That(products[2].Id, Is.EqualTo(2));
}
public void UsingSequentialGenerators()
{
// Arrange
var decimalGenerator = new SequentialGenerator<decimal>
{
Increment = 10,
Direction = GeneratorDirection.Descending
};
decimalGenerator.StartingWith(2000);
var intGenerator = new SequentialGenerator<int> { Increment = 10000 };
// Act
var list = Builder<Product>.CreateListOfSize(3)
.All()
.With(x => x.PriceBeforeTax = decimalGenerator.Generate())
.And(x => x.Id = intGenerator.Generate())
.Build();
// Assert
Assert.That(list[0].PriceBeforeTax, Is.EqualTo(2000));
Assert.That(list[1].PriceBeforeTax, Is.EqualTo(1990));
Assert.That(list[2].PriceBeforeTax, Is.EqualTo(1980));
Assert.That(list[0].Id, Is.EqualTo(0));
Assert.That(list[1].Id, Is.EqualTo(10000));
Assert.That(list[2].Id, Is.EqualTo(20000));
}
public void SequentialGenerator_DateTimeGeneration()
{
const int increment = 2;
var dateTimeGenerator = new SequentialGenerator<DateTime>
{
IncrementDateBy = IncrementDate.Day,
IncrementDateValueBy = increment
};
var startingDate = DateTime.MinValue;
dateTimeGenerator.StartingWith(startingDate);
var list = Builder<Product>.CreateListOfSize(2)
.All()
.With(x => x.Created = dateTimeGenerator.Generate())
.Build();
Assert.That(list[0].Created, Is.EqualTo(startingDate));
Assert.That(list[1].Created, Is.EqualTo(startingDate.AddDays(increment)));
}
