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));
}
