public void IntegerMinLargerThandMax()
{
ExecuteInTryCatch(() => IntegerGenerator.GenerateAsync(10, 100, 1).Wait());
Assert.AreEqual(1, _exceptionsThrown.Count);
Assert.True(_exceptionsThrown.First().ContainsInnerExceptionOfType(typeof(ArgumentException)));
}
public void DoubleTest()
{
// Arrange
int seed = 1337;
int rounds = 100;
Type doubleType = typeof(double);
IntegerGenerator ig1 = new IntegerGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <bool> gene1Success = new List <bool>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = ig1.Init(null, seed);
for (int i = 0; i < rounds; i++)
{
var genResult1 = ig1.Generate(null, wantedOutput: doubleType);
gene1Objects.Add(genResult1.result);
gene1Success.Add(genResult1.success);
ig1.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");
}
public void SeedTest()
{
// Arrange
int seed1 = 1337;
int seed2 = 13370;
int rounds = 100;
IntegerGenerator ig1 = new IntegerGenerator();
IntegerGenerator ig2 = new IntegerGenerator();
List <object> gene1Objects = new List <object>(capacity: rounds);
List <object> gene2Objects = new List <object>(capacity: rounds);
// Act
var shouldBeValidInitResult1 = ig1.Init(null, seed1);
var shouldBeValidInitResult2 = ig2.Init(null, seed2);
for (int i = 0; i < rounds; i++)
{
var genResult1 = ig1.Generate();
var genResult2 = ig2.Generate();
gene1Objects.Add(genResult1.result);
gene2Objects.Add(genResult2.result);
ig1.NextStep();
ig2.NextStep();
}
CollectionAssert.AreNotEqual(gene1Objects, gene2Objects);
}
public void InitTest()
{
// Arrange
object valid1 = null;
object invalid1 = new object();
int seed = 1337;
IntegerGenerator ig1 = new IntegerGenerator();
IntegerGenerator ig2 = new IntegerGenerator();
// Act
var shouldBeValidResult1 = ig1.Init(valid1, seed);
var shouldBeInvalidResult1 = ig2.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 IntegerNumberRequestedTooLargeTest()
{
ExecuteInTryCatch(() => IntegerGenerator.GenerateAsync((int)Math.Pow(10, 3) + 1, 1, 10).Wait());
Assert.AreEqual(1, _exceptionsThrown.Count);
Assert.True(_exceptionsThrown.First().ContainsInnerExceptionOfType(typeof(ArgumentException)));
}
public void IntegerMinAndMaxTheSame()
{
var result = IntegerGenerator.GenerateAsync(10, 10, 10).Result.ToList();
Assert.AreEqual(1, result.Count());
Assert.AreEqual(10, result.First());
}
public void IntegerMinValueTooSmallTest()
{
ExecuteInTryCatch(() => IntegerGenerator.GenerateAsync(10, (int)-Math.Pow(10, 8) - 1, 10000).Wait());
Assert.AreEqual(1, _exceptionsThrown.Count);
Assert.True(_exceptionsThrown.First().ContainsInnerExceptionOfType(typeof(ArgumentException)));
}
public void IntegerGeneratorWithDefaultTest()
{
IGenerator <int> intgen = new IntegerGenerator();
var checkme = (int)intgen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(0, 100));
}
public void IntegerGenerator_Generate_Output()
{
int expected = 100;
var generator = new IntegerGenerator(expected, 1);
int actual = generator.Generate();
Assert.Equal(expected, actual);
}
public void Equals_WhenNull_ReturnsFalse()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
var item1 = new TestObjectA(testInput1, testInput2);
item1.Equals(default(object)).Should().BeFalse();
}
public void Create_ShouldReturnCorrectLength()
{
var count = IntegerGenerator.AnyIntegerInRange(2, 100);
var result = _sut.BuildMany <TestClass>(count)
.Create();
result.Should().HaveCount(count);
}
public void IntegerGeneratorWithOverrideTest()
{
var min = 5;
var max = 20;
IGenerator <int> intgen = new IntegerGenerator(min, max);
var checkme = (int)intgen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(min, max));
}
public void Equals_WhenDerivedClass_ReturnsFalse()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
var item1 = new TestObjectB(testInput1, testInput2);
var item2 = new TestObjectC(testInput1, testInput2);
item1.Equals(item2).Should().BeFalse();
}
public void Equals_WhenNonEntity_ReturnsFalse()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
object item1 = new TestObjectA(testInput1, testInput2);
object item2 = testInput1;
item1.Equals(item2).Should().BeFalse();
}
public void IntegerGenerator_Generate_Properties()
{
int expected = 101;
var generator = new IntegerGenerator(expected, 1);
generator.Generate();
Assert.Equal(expected, generator.Current);
Assert.Equal(1, generator.Count);
}
public void Without_PropertyIsNotSet()
{
var count = IntegerGenerator.AnyIntegerInRange(2, 100);
var result = _sut.BuildMany <TestClass>(count)
.Without(r => r.StringProperty);
result.Select(r => r.Create().StringProperty)
.All(r => r == null).Should().BeTrue();
}
public void With_WhenPropertyValueIsPassedIn_PropertyHasValue()
{
var count = IntegerGenerator.AnyIntegerInRange(2, 100);
var value = StringGenerator.AnyNonNullString();
var result = _sut.BuildMany <TestClass>(count)
.With(r => r.StringProperty, value);
result.Select(r => r.Create().StringProperty).All(r => r.Equals(value)).Should().BeTrue();
}
public void Equals_WhenEqual_ReturnsTrue()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
var item1 = new TestObjectB(testInput1, testInput2);
var item2 = new TestObjectB(testInput1, testInput2);
item1.Equals(item2).Should().BeTrue();
}
public void GetHashCode_WhenCalled_ReturnsSameForSameValue()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
var expected = new TestObjectA(testInput1, testInput2).GetHashCode();
var actual = new TestObjectA(testInput1, testInput2).GetHashCode();
actual.Should().Be(expected);
}
public void GetHashCode_WhenCalled_ReturnsDifferentForDifferentValue()
{
var testInput1 = IntegerGenerator.AnyPositiveInteger();
var testInput2 = IntegerGenerator.AnyPositiveInteger();
var testInput3 = IntegerGenerator.AnyIntegerExcept(testInput2);
var test1 = new TestObjectA(testInput1, testInput2).GetHashCode();
var actual = new TestObjectA(testInput1, testInput3).GetHashCode();
actual.Should().NotBe(test1);
}
public void WithAutoProperties_ShouldNotSetAutoProperties()
{
_sut.OmitAutoProperties = false;
var count = IntegerGenerator.AnyIntegerInRange(2, 100);
var result = _sut.BuildMany <TestClass>(count)
.OmitAutoProperties();
result.Select(r => r.Create().StringProperty)
.All(r => r == null).Should().BeTrue();
}
public void IntegerGenerator_GenerateStep_Properties()
{
int iterations = 5;
int step = 4;
var generator = new IntegerGenerator(0, step);
for (int i = 0; i < iterations; i++)
{
generator.Generate();
}
Assert.Equal(iterations * step - 1 * step, generator.Current);
Assert.Equal(iterations * step - 2 * step, generator.Previous);
Assert.Equal(iterations, generator.Count);
}
public void IntegerGenerator_Value_ProvidesMassiveOfIntegersInSpecifiedRange()
{
int size = 1000;
IntegerGenerator intGen = new IntegerGenerator(1, 3);
int[] massive = new int[size];
for (int i = 0; i < size; i++)
{
massive[i] = intGen.Value();
}
var usedNumbers = massive.Distinct().OrderBy(i => i).ToList();
Assert.AreEqual(1, usedNumbers[0]);
Assert.AreEqual(2, usedNumbers[1]);
Assert.AreEqual(3, usedNumbers[2]);
}
public void With_WhenPropertyFunctionIsPassedIn_FuncIsExecutedCorrectTimes()
{
var count = IntegerGenerator.AnyIntegerInRange(2, 100);
var executed = 0;
string ValueFunction()
{
executed++;
return(StringGenerator.AnyNonNullString());
}
var result = _sut.BuildMany <TestClass>(count)
.With(r => r.StringProperty, ValueFunction);
result.ForEach(r => r.Create());
executed.Should().Be(count);
}
public static void Main(string[] args)
{
var result = IntegerGenerator.GenerateAsync(10, 1, 6).Result;
foreach (var item in result)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine("---");
result = SequenceGenerator.GenerateAsync(1, 6).Result;
foreach (var item in result)
{
Console.WriteLine(item.ToString());
}
}
public void Execute()
{
// Create sorting algorithm
SortingType sortingType = GetSortingType();
if (sortingType == SortingType.Exit)
{
return;
}
ISortingAlgorithm algorithm = GetSortingAlgorithm(sortingType);
// Get parameters
Console.WriteLine("How many runs?");
int runs = ProgramUtils.ReadLineInt();
Console.WriteLine("How many entries per run?");
int amount = ProgramUtils.ReadLineInt();
// Start runs
Stopwatch stopWatch = new Stopwatch();
IntegerGenerator generator = new IntegerGenerator();
Console.WriteLine("Sorting...");
long[] results = new long[runs];
for (int i = 0; i < runs; i++)
{
int[] items = generator.GenerateData(amount, -1_000_000, 1_000_000);
stopWatch.Start();
algorithm.Sort(items);
stopWatch.Stop();
results[i] = stopWatch.ElapsedMilliseconds;
stopWatch.Reset();
Console.Write($"\rProgress: {i+1}/{runs}");
}
ProgramUtils.WriteLineImpressive($"The average sorting time of {runs} runs is: {results.Average()} ms");
}
public void Execute()
{
Console.WriteLine("How many entries do you want to generate?");
int entries = ProgramUtils.ReadLineInt();
Console.WriteLine("What's the minimum integer?");
int min = ProgramUtils.ReadLineInt();
Console.WriteLine("What's the maximum integer?");
int max = ProgramUtils.ReadLineInt();
Console.WriteLine("What's the output file name?");
string filename = Console.ReadLine();
IntegerGenerator generator = new IntegerGenerator();
int[] data = generator.GenerateData(entries, min, max);
string[] lines = Array.ConvertAll(data, i => i.ToString());
File.WriteAllLines(filename, lines);
ProgramUtils.WriteLineImpressive($"Succesfully wrote {entries} random integers in range [{min} - {max}] to {filename}!");
}
public void LoadTest()
{
// Arrange
int seed = 13237;
string range = "2,556";
string loadString = $"~{range}~{seed}";
IntegerGenerator ig1 = new IntegerGenerator();
IntegerGenerator ig2 = new IntegerGenerator();
IntegerGenerator ig3 = new IntegerGenerator();
List <int> results1 = new List <int>();
List <int> results2 = new List <int>();
List <int> results3 = new List <int>();
// Act
var shouldBeValidInitResult1 = ig1.Init(range, seed);
var shouldBeValidInitResult2 = ig3.Init(null, 0);
var shouldBeValidLoadResult = ig2.Load(loadString);
for (int i = 0; i < 13; i++)
{
results1.Add((int)ig1.Generate().result);
results2.Add((int)ig2.Generate().result);
results3.Add((int)ig3.Generate().result);
}
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success);
Assert.IsTrue(shouldBeValidInitResult2.success);
Assert.IsTrue(shouldBeValidLoadResult.success);
CollectionAssert.AreEqual(results1, results2);
Assert.IsTrue(results1.All(item => item >= 2 && item < 556));
CollectionAssert.AreNotEqual(results1, results3);
}
public void SaveTest()
{
// Arrange
int seed = 1337;
IntegerGenerator ig1 = new IntegerGenerator();
IntegerGenerator ig2 = new IntegerGenerator();
string initString = $"1,33";
// Act
var shouldBeValidInitResult1 = ig1.Init(null, 0);
string ig1String = ig1.Save();
var shouldBeValidInitResult2 = ig2.Init(initString, seed);
string ig2String = ig2.Save();
// Assert
Assert.IsTrue(shouldBeValidInitResult1.success);
Assert.IsTrue(shouldBeValidInitResult2.success);
Assert.AreEqual("~~0", ig1String, "Default Init should not store any parameters");
Assert.AreEqual($"~{initString}~{seed}", ig2String, "Init string should be saved");
}
public GeneratePostsIterator(Session session, int seed = 0, int quantity = 100)
{
Session = session;
Seed = seed;
Quantity = quantity;
Random random = Seed != 0 ? new Random(Seed) : new Random();
ThreeGen = new IntegerGenerator(random, 1, 3);
SixGen = new IntegerGenerator(random, 1, 6);
StrLenGen = new IntegerGenerator(random, 1, 40);
UpcharGen = new CharGenerator(random, 'A', 'Z');
DowncharGen = new CharGenerator(random, 'a', 'z');
NumcharGen = new CharGenerator(random, '0', '9');
TruthGen = new BoolGenerator(random);
NegNumberGen = new DoubleGenerator(random, -10000, -1);
PosNumberGen = new DoubleGenerator(random, 1, 10000);
YearGen = new IntegerGenerator(random, 1900, 2300);
MonGen = new IntegerGenerator(random, 1, 12);
DayGen = new IntegerGenerator(random, 1, 28);
NextDate = TimesCommon.Current.ParseDate(GenerateDate());
NextAuxDate = TimesCommon.Current.ParseDate(GenerateDate());
}
public void IntegerGeneratorWithDefaultTest()
{
IGenerator<int> intgen = new IntegerGenerator();
var checkme = (int) intgen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(0, 100));
}
public void IntegerGeneratorWithOverrideTest()
{
var min = 5;
var max = 20;
IGenerator<int> intgen = new IntegerGenerator(min, max);
var checkme = (int) intgen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(min, max));
}
