public void ShouldBeAbleToUseADateTime() { var generator = new SequentialGenerator <DateTime>(); generator.Generate().ShouldBe(DateTime.MinValue); generator.Generate().ShouldBe(DateTime.MinValue.AddDays(1)); }
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 ShouldBeAbleToUseABoolean() { var generator = new SequentialGenerator <bool>(); generator.Generate().ShouldBe(false); generator.Generate().ShouldBe(true); generator.Generate().ShouldBe(false); }
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)); }
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 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>(); generator.Generate().ShouldBe(0f); generator.Generate().ShouldBe(1f); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe(0f); generator.Generate().ShouldBe(-1f); }
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 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 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 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>(); 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 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 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 ShouldBeAbleToUseALong() { var generator = new SequentialGenerator <long>(); generator.Generate().ShouldBe(0); generator.Generate().ShouldBe(1); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe(0); generator.Generate().ShouldBe(-1); }
public void GivenGeneratorIsUnique_WhenGeneratingIntegers_ThenShouldThrowAtEndOfList() { var sut = new SequentialGenerator(0, 2, true); for (int index = sut.StartIndex; index < sut.ListSize; index++) { sut.Generate().ShouldBe(index); } Should.Throw <InvalidOperationException>(() => sut.Generate()) .Message.ShouldBe("There are not enough elements in the data source to continue adding items"); }
public void ShouldBeAbleToUseAByte() { var generator = new SequentialGenerator <byte>(); generator.Generate().ShouldBe((byte)0); generator.Generate().ShouldBe((byte)1); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe((byte)0); generator.Generate().ShouldBe((byte)0); }
public void ShouldBeAbleToUseAShort() { var generator = new SequentialGenerator <short>(); generator.Generate().ShouldBe((short)0); generator.Generate().ShouldBe((short)1); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe((short)0); generator.Generate().ShouldBe((short)-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)); }
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 void ShouldBeAbleToUseAChar() { var generator = new SequentialGenerator <char>(); generator.StartingWith('A'); generator.Generate().ShouldBe('A'); generator.Generate().ShouldBe('B'); generator.Generate().ShouldBe('C'); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe('B'); generator.Generate().ShouldBe('A'); }
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 ShouldBeAbleToUseADecimal() { var generator = new SequentialGenerator <decimal> { Increment = .5m }; generator.Generate().ShouldBe(0m); generator.Generate().ShouldBe(0.5m); generator.Generate().ShouldBe(1m); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe(0.5m); generator.Generate().ShouldBe(0m); }
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)); }
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 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 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 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)); }
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 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 WhenGeneratingIntegers_ThenShouldBeSequential() { var sut = new SequentialGenerator(0, 11); for (int index = sut.StartIndex; index < sut.ListSize; index++) { sut.Generate().ShouldBe(index); } }
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 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 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 Generate_DefaultSetUp_IncrementsFromMinDateTimeValue() { generator = new SequentialGenerator<DateTime>(); Assert.That(generator.Generate(), Is.EqualTo(DateTime.MinValue)); }
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 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 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 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))); }
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 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)); }