public void LoadTest()
{
// Arrange
int seed = 1337;
int start = 100;
int step = 137;
string initString = $"start={start}|step={step}";
string loadString = $"~{initString}~0";
RunningNumberGenerator rg1 = new RunningNumberGenerator();
RunningNumberGenerator rg2 = new RunningNumberGenerator();
List <int> results1 = new List <int>();
List <int> results2 = new List <int>();
// Act
var shouldBeValidInitResult = rg1.Init(initString, seed);
var shouldBeValidLoadResult = rg2.Load(loadString);
for (int i = 0; i < 13; i++)
{
results1.Add((int)rg1.Generate().result);
results2.Add((int)rg2.Generate().result);
}
// Assert
Assert.IsTrue(shouldBeValidInitResult.success);
Assert.IsTrue(shouldBeValidLoadResult.success);
CollectionAssert.AreEqual(results1, results2);
}
public void JsonOutputTest()
{
// Arrange
GenerateData generateData = new GenerateData();
RunningNumberGenerator runningNumberGenerator = new RunningNumberGenerator();
generateData.AddGeneratorToChain(runningNumberGenerator);
NameGenerator nameGenerator = new NameGenerator();
nameGenerator.Init(null, seed: 1337);
generateData.AddGeneratorToChain(nameGenerator);
generateData.AddWantedElement(("Id", runningNumberGenerator, null, typeof(int), null));
generateData.AddWantedElement(("Firstname", nameGenerator, "firstname", typeof(string), null));
generateData.AddWantedElement(("Lastname", nameGenerator, "lastname", typeof(string), null));
JsonOutput outJson = new JsonOutput();
generateData.output = outJson;
MemoryStream ms = new MemoryStream();
// Act
generateData.Generate(ms);
string result = Encoding.UTF8.GetString(ms.ToArray());
List <IdFirstnameLastname> idFirstnameLastnameList = JsonConvert.DeserializeObject <List <IdFirstnameLastname> >(result);
// Assert
Assert.AreEqual(generateData.howManyStepToRun, idFirstnameLastnameList.Count, "There should be certain amount of wanted items");
Assert.AreEqual("Jacob", idFirstnameLastnameList[0].Firstname);
Assert.AreEqual("Smith", idFirstnameLastnameList[0].Lastname);
Assert.AreEqual(0, idFirstnameLastnameList[0].Id);
}
public void SaveTest()
{
// Arrange
int seed = 1337;
RunningNumberGenerator rg1 = new RunningNumberGenerator();
RunningNumberGenerator rg2 = new RunningNumberGenerator();
RunningNumberGenerator rg3 = new RunningNumberGenerator();
RunningNumberGenerator rg4 = new RunningNumberGenerator();
int start2 = 100;
int step2 = 137;
string initString2 = $"start={start2}|step={step2}";
// Act
var shouldBeValidInitResult1 = rg1.Init(null, seed);
string rg1String = rg1.Save();
var shouldBeValidInitResult2 = rg2.Init(initString2, seed);
string rg2String = rg2.Save();
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success);
Assert.IsTrue(shouldBeValidInitResult2.success);
Assert.AreEqual("~~0", rg1String, "Default Init should not have anything to save");
Assert.AreEqual($"~{initString2}~0", rg2String, "Init string should be saved");
}
public void InitTest()
{
// Arrange
object valid1 = null;
object invalid1 = new object();
int seed = 1337;
RunningNumberGenerator rg1 = new RunningNumberGenerator();
RunningNumberGenerator rg2 = new RunningNumberGenerator();
// Act
var shouldBeValidResult1 = rg1.Init(valid1, seed);
var shouldBeInvalidResult1 = rg2.Init(invalid1, seed);
// Assert
Assert.IsTrue(shouldBeValidResult1.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidResult1.possibleError), "Init should NOT have an error");
Assert.IsFalse(shouldBeInvalidResult1.success, "Init should have failed");
Assert.IsFalse(string.IsNullOrEmpty(shouldBeInvalidResult1.possibleError), "Init should have an error");
}
public void TwoGeneratorTest()
{
// Arrange
string expectedOutput = string.Join(Environment.NewLine, new string[] {
"Id,Firstname,Lastname",
"0,Jacob,Smith",
"1,Sophia,Johnson",
"2,Mason,Williams",
"3,Isabella,Brown",
"4,William,Jones",
"5,Emma,Garcia",
"6,Jayden,Miller",
"7,Olivia,Davis",
"8,Noah,Rodriguez",
"9,Ava,Martinez",
"" // Newline
});
GenerateData generateData = new GenerateData();
RunningNumberGenerator runningNumberGenerator = new RunningNumberGenerator();
generateData.AddGeneratorToChain(runningNumberGenerator);
NameGenerator nameGenerator = new NameGenerator();
nameGenerator.Init(null, seed: 1337);
generateData.AddGeneratorToChain(nameGenerator);
generateData.AddWantedElement(("Id", runningNumberGenerator, null, typeof(int), null));
generateData.AddWantedElement(("Firstname", nameGenerator, "firstname", typeof(string), null));
generateData.AddWantedElement(("Lastname", nameGenerator, "lastname", typeof(string), null));
SomeSeparatedValueOutput outCSV = new SomeSeparatedValueOutput();
generateData.output = outCSV;
MemoryStream ms = new MemoryStream();
// Act
generateData.Generate(ms);
string result = Encoding.UTF8.GetString(ms.ToArray());
// Assert
Assert.AreEqual(expectedOutput, result);
}
public void SimpleGeneratorSerializationTest()
{
// Arrange
GenerateData generateData = new GenerateData();
RunningNumberGenerator runningNumberGenerator = new RunningNumberGenerator();
generateData.AddGeneratorToChain(runningNumberGenerator);
generateData.AddWantedElement(("Id", runningNumberGenerator, typeof(int), null, null));
SomeSeparatedValueOutput outCSV = new SomeSeparatedValueOutput();
generateData.output = outCSV;
string expected = $"DATAGEN VERSION 1{Environment.NewLine}DATA GENERATORS:{Environment.NewLine}1 RUN~~0{Environment.NewLine}MUTATOR CHAINS:{Environment.NewLine}WANTED ELEMENTS:{Environment.NewLine}-Id~1~_{Environment.NewLine}OUTPUTTER:{Environment.NewLine}XSV~{Environment.NewLine}";
// Act
string serialized = generateData.Save();
// Assert
Assert.AreEqual(expected, serialized);
}
public void GenerateLongsTest()
{
// Arrange
int seed = 1337;
int rounds = 100;
Type longType = typeof(long);
RunningNumberGenerator rg1 = new RunningNumberGenerator();
long intMax = int.MaxValue;
List <object> gene1Objects = new List <object>(capacity: rounds);
List <bool> gene1Success = new List <bool>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = rg1.Init($"start={intMax}|step=3", seed);
for (int i = 0; i < rounds; i++)
{
var genResult1 = rg1.Generate(null, longType);
gene1Objects.Add(genResult1.result);
gene1Success.Add(genResult1.success);
rg1.NextStep();
}
// Assert
Assert.AreEqual(rounds, gene1Objects.Count);
Assert.AreEqual(rounds, gene1Success.Count);
CollectionAssert.AllItemsAreInstancesOfType(gene1Objects, longType, "There should be only longs generated");
CollectionAssert.AllItemsAreUnique(gene1Objects);
}
public void SimpleSmokeTest()
{
// Arrange
string expectedOutput = string.Join(Environment.NewLine, new string[] {
"Id",
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"" // Newline
});
GenerateData generateData = new GenerateData();
RunningNumberGenerator runningNumberGenerator = new RunningNumberGenerator();
generateData.AddGeneratorToChain(runningNumberGenerator);
generateData.AddWantedElement(("Id", runningNumberGenerator, typeof(int), null, null));
SomeSeparatedValueOutput outCSV = new SomeSeparatedValueOutput();
generateData.output = outCSV;
MemoryStream ms = new MemoryStream();
// Act
generateData.Generate(ms);
string result = Encoding.UTF8.GetString(ms.ToArray());
// Assert
Assert.AreEqual(expectedOutput, result);
}
public void DoubleTest()
{
// Arrange
int seed = 1337;
int rounds = 100;
Type doubleType = typeof(double);
RunningNumberGenerator rg1 = new RunningNumberGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <bool> gene1Success = new List <bool>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = rg1.Init(null, seed);
for (int i = 0; i < rounds; i++)
{
var genResult1 = rg1.Generate(null, wantedOutput: doubleType);
gene1Objects.Add(genResult1.result);
gene1Success.Add(genResult1.success);
rg1.NextStep();
}
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult1.possibleError), "Init should NOT have an error");
Assert.AreEqual(rounds, gene1Objects.Count);
Assert.AreEqual(rounds, gene1Success.Count);
CollectionAssert.AllItemsAreInstancesOfType(gene1Objects, doubleType, "There should be only doubles generated");
CollectionAssert.AllItemsAreUnique(gene1Objects);
}
public void GenerateIntsTest()
{
// Arrange
int seed = 1337;
int rounds = 100;
RunningNumberGenerator rg1 = new RunningNumberGenerator();
RunningNumberGenerator rg2 = new RunningNumberGenerator();
RunningNumberGenerator rg3 = new RunningNumberGenerator();
RunningNumberGenerator rg4 = new RunningNumberGenerator();
RunningNumberGenerator rg5 = new RunningNumberGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <object> gene2Objects = new List <object>(capacity: rounds);
List <object> gene3Objects = new List <object>(capacity: rounds);
List <object> gene4Objects = new List <object>(capacity: rounds);
List <object> gene5Objects = new List <object>(capacity: rounds);
List <bool> gene1Success = new List <bool>(capacity: rounds);
List <bool> gene2Success = new List <bool>(capacity: rounds);
List <bool> gene3Success = new List <bool>(capacity: rounds);
List <bool> gene4Success = new List <bool>(capacity: rounds);
List <bool> gene5Success = new List <bool>(capacity: rounds);
int start2 = 100;
int step2 = 137;
int start3 = -1;
int step3 = -1;
int start4 = 123456;
int step4 = -1687;
int start5 = int.MinValue;
int step5 = 12405;
// Act
var shouldBeValidInitResult1 = rg1.Init(null, seed);
var shouldBeValidInitResult2 = rg2.Init($"start={start2}|step={step2}", seed);
var shouldBeValidInitResult3 = rg3.Init($"start={start3}|inc={step3}", seed);
var shouldBeValidInitResult4 = rg4.Init($"begin={start4}|step={step4}", seed);
var shouldBeValidInitResult5 = rg5.Init($"init={start5}|step={step5}", seed);
for (int i = 0; i < rounds; i++)
{
var genResult1 = rg1.Generate();
var genResult2 = rg2.Generate();
var genResult3 = rg3.Generate();
var genResult4 = rg4.Generate();
var genResult5 = rg5.Generate();
gene1Objects.Add(genResult1.result);
gene2Objects.Add(genResult2.result);
gene3Objects.Add(genResult3.result);
gene4Objects.Add(genResult4.result);
gene5Objects.Add(genResult5.result);
gene1Success.Add(genResult1.success);
gene2Success.Add(genResult2.success);
gene3Success.Add(genResult3.success);
gene4Success.Add(genResult4.success);
gene5Success.Add(genResult5.success);
rg1.NextStep();
rg2.NextStep();
rg3.NextStep();
rg4.NextStep();
rg5.NextStep();
}
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult1.possibleError), "Init should NOT have an error");
Assert.IsTrue(shouldBeValidInitResult2.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult2.possibleError), "Init should NOT have an error");
Assert.IsTrue(shouldBeValidInitResult3.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult3.possibleError), "Init should NOT have an error");
Assert.IsTrue(shouldBeValidInitResult4.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult4.possibleError), "Init should NOT have an error");
Assert.IsTrue(shouldBeValidInitResult5.success, "Init should have been successful");
Assert.IsTrue(string.IsNullOrEmpty(shouldBeValidInitResult5.possibleError), "Init should NOT have an error");
Assert.AreEqual(rounds, gene1Objects.Count);
Assert.AreEqual(rounds, gene2Objects.Count);
Assert.AreEqual(rounds, gene3Objects.Count);
Assert.AreEqual(rounds, gene4Objects.Count);
Assert.AreEqual(rounds, gene5Objects.Count);
Assert.AreEqual(rounds, gene1Success.Count);
Assert.AreEqual(rounds, gene2Success.Count);
Assert.AreEqual(rounds, gene3Success.Count);
Assert.AreEqual(rounds, gene4Success.Count);
Assert.AreEqual(rounds, gene5Success.Count);
CollectionAssert.AllItemsAreInstancesOfType(gene1Objects, typeof(int), "There should be only ints generated");
CollectionAssert.AllItemsAreInstancesOfType(gene2Objects, typeof(int), "There should be only ints generated");
CollectionAssert.AllItemsAreInstancesOfType(gene3Objects, typeof(int), "There should be only ints generated");
CollectionAssert.AllItemsAreInstancesOfType(gene4Objects, typeof(int), "There should be only ints generated");
CollectionAssert.AllItemsAreInstancesOfType(gene5Objects, typeof(int), "There should be only ints generated");
CollectionAssert.AllItemsAreUnique(gene1Objects);
Assert.AreEqual(0, gene1Objects[0]);
Assert.AreEqual(99, gene1Objects[99]);
CollectionAssert.AllItemsAreUnique(gene2Objects);
Assert.AreEqual(start2, gene2Objects[0]);
Assert.AreEqual(start2 + (rounds - 1) * step2, gene2Objects[99]);
CollectionAssert.AllItemsAreUnique(gene3Objects);
Assert.AreEqual(start3, gene3Objects[0]);
Assert.AreEqual(start3 + (rounds - 1) * step3, gene3Objects[99]);
CollectionAssert.AllItemsAreUnique(gene4Objects);
Assert.AreEqual(start4, gene4Objects[0]);
Assert.AreEqual(start4 + (rounds - 1) * step4, gene4Objects[99]);
CollectionAssert.AllItemsAreUnique(gene5Objects);
Assert.AreEqual(start5, gene5Objects[0]);
Assert.AreEqual(start5 + (rounds - 1) * step5, gene5Objects[99]);
}
