public void DoubleGeneratorWithDefaultValues()
{
IGenerator <double> doublegen = new DoubleGenerator();
var checkme = (double)doublegen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(0.00, 100.00));
}
public void DoubleGenerator_Value_ProvidesSeriesOfDoubleValaues()
{
Random random = new Random(200);
int count = 1000;
DoubleGenerator dblGen = new DoubleGenerator(random, 2, 3);
for (int i = 0; i < count; i++)
{
double val = dblGen.Value();
Assert.IsTrue(val >= 2);
Assert.IsTrue(val < 3);
}
}
public void GenerateWorks(double value, string expected)
{
// Arrange
var random = new Mock <IRandomNumber>();
var x = random.Setup(x => x.Next(double.MinValue, double.MaxValue)).Returns(value);
var sut = new DoubleGenerator(random.Object);
// Act
var result = sut.Generate();
// assert
Assert.Equal(expected, result);
}
public void Execute()
{
Console.WriteLine("How many entries do you want to generate?");
int entries = ProgramUtils.ReadLineInt();
Console.WriteLine("What's the minimum double?");
double min = ProgramUtils.ReadLineDouble();
Console.WriteLine("What's the maximum double?");
double max = ProgramUtils.ReadLineDouble();
Console.WriteLine("What's the output file name?");
string filename = Console.ReadLine();
DoubleGenerator generator = new DoubleGenerator();
double[] 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 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 GeneratorOptions <T> Range(Expression <Func <T, double> > propertyExpression, double min, double max)
{
var generator = new DoubleGenerator(min, max);
return(For(propertyExpression, generator));
}
public DoubleGeneratorTest()
{
ValueGenerator = new DoubleGenerator(RandomValuesGenerator);
}
public Faker(string dirPath)
{
List <Assembly> allAssemblies = new List <Assembly>();
foreach (string dll in Directory.GetFiles(dirPath, "*.dll"))
{
allAssemblies.Add(Assembly.LoadFile(dll));
}
collectionTypeGenerator = new Dictionary <string, ICollectionGenerator>();
basicTypeGenerator = new Dictionary <Type, IGenerator>();
var doubleGenerator = new DoubleGenerator();
basicTypeGenerator.Add(doubleGenerator.GetGeneratorType(), doubleGenerator);
var uintGenerator = new UIntGenerator();
basicTypeGenerator.Add(uintGenerator.GetGeneratorType(), uintGenerator);
var floatGenerator = new FloatGenerator();
basicTypeGenerator.Add(floatGenerator.GetGeneratorType(), floatGenerator);
var charGenerator = new CharGenerator();
basicTypeGenerator.Add(charGenerator.GetGeneratorType(), charGenerator);
var stringGenerator = new StringGenerator();
basicTypeGenerator.Add(stringGenerator.GetGeneratorType(), stringGenerator);
var longGenerator = new LongGenerator();
basicTypeGenerator.Add(longGenerator.GetGeneratorType(), longGenerator);
var datetimeGenerator = new DateGenerator();
basicTypeGenerator.Add(datetimeGenerator.GetGeneratorType(), datetimeGenerator);
foreach (var asm in allAssemblies)
{
Console.WriteLine(asm.FullName);
var types = asm.GetTypes().Where(t => t.GetInterfaces().Where(i => i.Equals(typeof(IGenerator))).Any());
foreach (var type in types)
{
var plugin = asm.CreateInstance(type.FullName) as IGenerator;
Type t = plugin.GetGeneratorType();
if (!basicTypeGenerator.ContainsKey(t))
{
basicTypeGenerator.Add(plugin.GetGeneratorType(), plugin);
}
}
}
var listGenerator = new ListGenerator();
collectionTypeGenerator.Add(listGenerator.GetGeneratorType().Name, listGenerator);
recursionList = new List <Type>();
}
/// <summary>
/// A factory for returning the appropriate generator
/// </summary>
/// <param name="thisCustomAttribute">The decoration defining the generator</param>
/// <param name="thisPropInfo">The reflected values of the property</param>
/// <returns>IRandomGenerator</returns>
private IDataGenerator GetGenerator(CustomAttributeData thisCustomAttribute, PropertyInfo thisPropInfo)
{
IDataGenerator generator = null;
switch (thisCustomAttribute.AttributeType.Name)
{
case "IntegerGenerator":
generator = new IntegerGenerator();
break;
case "SingleGenerator":
generator = new SingleGenerator();
break;
case "SingleRangeGenerator":
generator = GetPropertyInfoAttribute <SingleRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DoubleRangeGenerator(Single.MinValue, Single.MaxValue);
}
break;
case "DoubleGenerator":
generator = new DoubleGenerator();
break;
case "NormallyDistributedDoubleGenerator":
generator = GetPropertyInfoAttribute <NormallyDistributedDoubleGenerator>(thisPropInfo);
if (generator == null)
{
generator = new NormallyDistributedDoubleGenerator(0, 1);
}
break;
case "DoubleRangeGenerator":
generator = GetPropertyInfoAttribute <DoubleRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DoubleRangeGenerator(double.MinValue, double.MaxValue);
}
break;
case "BoolGenerator":
generator = new BoolGenerator();
break;
case "IntegerRangeGenerator":
generator = GetPropertyInfoAttribute <IntegerRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new IntegerRangeGenerator(int.MinValue, int.MaxValue);
}
break;
case "StringRangeGenerator":
generator = GetPropertyInfoAttribute <StringRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new StringRangeGenerator(new string[] { "" });
}
break;
case "DateRangeGenerator":
generator = GetPropertyInfoAttribute <DateRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DateRangeGenerator(DateTime.MinValue, DateTime.MaxValue);
}
break;
case "StringFromFileGenerator":
string pathAsKey = thisCustomAttribute.ConstructorArguments.First().ToString();
// this is a cached generator, stored for the sake of not having to re-process the file
if (cacheGenerators.ContainsKey(pathAsKey))
{
generator = cacheGenerators[pathAsKey];
}
else
{
// process the gerneator
generator = GetPropertyInfoAttribute <StringFromFileGenerator>(thisPropInfo);
// add to a cache
cacheGenerators.Add(pathAsKey, generator);
}
if (generator == null)
{
generator = new StringRangeGenerator(new string[] { "" });
}
break;
case "IntegerSequenceGenerator":
var key = thisPropInfo.Name + "/" + thisCustomAttribute.AttributeType.Name;
if (cacheGenerators.ContainsKey(key))
{
generator = cacheGenerators[key];
}
else
{
// process the gerneator
generator = GetPropertyInfoAttribute <IntegerSequenceGenerator>(thisPropInfo);
// add to a cache
cacheGenerators.Add(key, generator);
}
if (generator == null)
{
generator = new IntegerSequenceGenerator();
}
break;
case "DecimalGenerator":
generator = new DecimalGenerator();
break;
case "DecimalRangeGenerator":
generator = GetPropertyInfoAttribute <DecimalRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DecimalRangeGenerator(double.MinValue, double.MaxValue);
}
break;
default:
break;
}
return(generator);
}
public void DoubleGeneratorWithDefaultValues()
{
IGenerator<double> doublegen = new DoubleGenerator();
var checkme = (double) doublegen.Generate();
Assert.IsNotNull(checkme);
Assert.That(checkme, Is.InRange(0.00, 100.00));
}
