public static ulong ULong(ulong maxValue)
{
return(Any.Value <ulong>(
new MaxValueConstraint <ulong>(maxValue)
));
}
public static uint UInt(uint maxValue)
{
return(Any.Value <uint>(
new MaxValueConstraint <uint>(maxValue)
));
}
public static ulong ULong()
{
return(Any.Value <ulong>());
}
public static string String()
{
return(Any.Value <string>());
}
public static sbyte SByte(sbyte maxValue)
{
return(Any.Value <sbyte>(
new MaxValueConstraint <sbyte>(maxValue)
));
}
/// <summary>
/// Returns a random double between 0.0 and 1.0.
/// </summary>
/// <returns>A random double between 0.0 and 1.0.</returns>
public static double Double()
{
return(Any.Value <double>());
}
/// <summary>
/// Returns a random decimal between 0.0 and 1.0.
/// </summary>
/// <returns>A random decimal between 0.0 and 1.0.</returns>
public static decimal Decimal()
{
return(Any.Value <decimal>());
}
public static long Long(long maxValue)
{
return(Any.Value <long>(
new MaxValueConstraint <long>(maxValue)
));
}
public static byte Byte()
{
return(Any.Value <byte>());
}
/// <summary>
/// Returns a random non-negative integer value.
/// </summary>
/// <param name="maxValue">A maximal possible value.</param>
/// <returns>A non-negative integer value.</returns>
public static int Integer(int maxValue)
{
return(Any.Value <int>(
new MaxValueConstraint <int>(maxValue)
));
}
public static long Long()
{
return(Any.Value <long>());
}
public static int Integer()
{
return(Any.Value <int>());
}
public static short Short(short maxValue)
{
return(Any.Value <short>(
new MaxValueConstraint <short>(maxValue)
));
}
public static short Short()
{
return(Any.Value <sbyte>());
}
/// <summary>
/// Returns a random float between 0.0 and 1.0.
/// </summary>
/// <returns>A random float between 0.0 and 1.0.</returns>
public static float Float()
{
return(Any.Value <float>());
}
public static byte Byte(byte maxValue)
{
return(Any.Value <byte>(
new MaxValueConstraint <byte>(maxValue)
));
}
public static float Float(float maxValue)
{
return(Any.Value <float>(
new MaxValueConstraint <float>(maxValue)
));
}
public static ushort UShort()
{
return(Any.Value <ushort>());
}
public static double Double(double maxValue)
{
return(Any.Value <double>(
new MaxValueConstraint <double>(maxValue)
));
}
public static ushort UShort(ushort maxValue)
{
return(Any.Value <ushort>(
new MaxValueConstraint <ushort>(maxValue)
));
}
public static decimal Decimal(decimal maxValue)
{
return(Any.Value <decimal>(
new MaxValueConstraint <decimal>(maxValue)
));
}
public static uint UInt()
{
return(Any.Value <uint>());
}
/// <summary>
/// Returns a random value of a specified type using registered generators.
/// </summary>
/// <typeparam name="T">A type of value to generate.</typeparam>
/// <param name="constraints">Optional constraints to be applied to a generated value.</param>
/// <returns>A value of a specified type.</returns>
public static T Value <T>(params IConstraint[] constraints)
{
return((T)Any.Value(typeof(T), constraints));
}
public static sbyte SByte()
{
return(Any.Value <sbyte>());
}
