public object Generate <T>()
{
T enumObj;
if (!typeof(T).IsInterface && !typeof(T).IsAbstract)
{
enumObj = (T)Activator.CreateInstance(typeof(T));
Type genericTypeArgument = typeof(T).GetGenericArguments().First();
for (int i = 0; i < 10; ++i)
{
object argument = new object();
string typeName;
if (_supportedTypes.Has(genericTypeArgument, out typeName))
{
switch (typeName)
{
case "Byte":
IRandomValueGenerator byteGenerator = new RandomByteGenerator();
argument = byteGenerator.Generate <T>();
break;
case "Double":
IRandomValueGenerator doubleGenerator = new RandomDoubleGenerator();
argument = doubleGenerator.Generate <T>();
break;
case "Boolean":
IRandomValueGenerator boolGenerator = new RandomBoolGenerator();
argument = boolGenerator.Generate <T>();
break;
case "String":
IRandomValueGenerator stringGenerator = new RandomStringGenerator();
argument = stringGenerator.Generate <T>();
break;
case "DateTime":
IRandomValueGenerator dateTimeGenerator = new RandomDateTimeGenerator.RandomDateTimeGenerator();
argument = dateTimeGenerator.Generate <T>();
break;
}
MethodInfo method = typeof(T).GetMethod("Add");
method.Invoke(enumObj, new object[] { argument });
}
else
{
throw new Exception();
}
}
return(enumObj);
}
return(null);
}
public void Constructs_with_invalid_property_should_throw_exception(double minimum, double maximum, int count)
{
var generator = new RandomDoubleGenerator
{
Minimum = minimum,
Maximum = maximum,
Count = count
};
Assert.Throws<GenerationException>(() => generator.Run().Cast<double>().ToArray());
}
public void Constructs_with_invalid_property_should_throw_exception(double minimum, double maximum, int count)
{
var generator = new RandomDoubleGenerator
{
Minimum = minimum,
Maximum = maximum,
Count = count
};
Assert.Throws <GenerationException>(() => generator.Run().Cast <double>().ToArray());
}
/// <summary>
/// Returns the an enumeration of random numbers.
/// </summary>
/// <param name="count">The number of strings to generate.</param>
/// <param name="minimum">The lower bound of the range.</param>
/// <param name="maximum">The upper bound of the range.</param>
/// <returns>An enumeration of random number values.</returns>
/// <exception cref="GenerationException">Thrown if the specified parameters are inconsistent or invalid.</exception>
public static IEnumerable<double> Numbers(int count, double minimum, double maximum)
{
var generator = new RandomDoubleGenerator
{
Count = count,
Minimum = minimum,
Maximum = maximum,
};
foreach (double value in generator.Run())
yield return value;
}
public void WriteBigEndianDoubleArray()
{
var integers = new RandomDoubleGenerator(1).Structs;
using (var extendedStream = new BigEndianMemoryStream(new Reloaded.Memory.Streams.ExtendedMemoryStream()))
{
extendedStream.Write(integers);
Reloaded.Memory.StructArray.FromArrayBigEndianPrimitive <Double>(extendedStream.ToArray(), out var newStructs);
Assert.Equal(integers, newStructs);
};
}
/// <summary>
/// Returns the an enumeration of random numbers.
/// </summary>
/// <param name="count">The number of strings to generate.</param>
/// <param name="minimum">The lower bound of the range.</param>
/// <param name="maximum">The upper bound of the range.</param>
/// <returns>An enumeration of random number values.</returns>
/// <exception cref="GenerationException">Thrown if the specified parameters are inconsistent or invalid.</exception>
public static IEnumerable <double> Numbers(int count, double minimum, double maximum)
{
var generator = new RandomDoubleGenerator
{
Count = count,
Minimum = minimum,
Maximum = maximum,
};
foreach (double value in generator.Run())
{
yield return(value);
}
}
public void Generate_sequence_ok(double minimum, double maximum, int count)
{
var generator = new RandomDoubleGenerator
{
Minimum = minimum,
Maximum = maximum,
Count = count
};
var values = generator.Run().Cast<double>().ToArray();
Assert.Count(count, values);
Assert.Multiple(() =>
{
foreach (double value in values)
{
Assert.Between(value, minimum, maximum);
}
});
}
public void Generate_sequence_ok(double minimum, double maximum, int count)
{
var generator = new RandomDoubleGenerator
{
Minimum = minimum,
Maximum = maximum,
Count = count
};
var values = generator.Run().Cast <double>().ToArray();
Assert.Count(count, values);
Assert.Multiple(() =>
{
foreach (double value in values)
{
Assert.Between(value, minimum, maximum);
}
});
}
public void Generate_filtered_sequence()
{
var generator = new RandomDoubleGenerator
{
Minimum = 0,
Maximum = 100,
Count = 50,
Filter = d => ((int)d % 2) == 0
};
var values = generator.Run().Cast <double>().ToArray();
Assert.Count(50, values);
Assert.Multiple(() =>
{
foreach (double value in values)
{
Assert.AreEqual(0, (int)value % 2);
}
});
}
public void Generate_filtered_sequence()
{
var generator = new RandomDoubleGenerator
{
Minimum = 0,
Maximum = 100,
Count = 50,
Filter = d => ((int)d % 2) == 0
};
var values = generator.Run().Cast<double>().ToArray();
Assert.Count(50, values);
Assert.Multiple(() =>
{
foreach (double value in values)
{
Assert.AreEqual(0, (int)value % 2);
}
});
}