/// <summary>
/// Initializes a new instance of the CollectionStructuralDataGenerator class.
/// </summary>
/// <param name="itemDataGenerator">The data generator for an item of the collection.</param>
/// <param name="random">Random number generator.</param>
/// <param name="minCount">Collection minimum count.</param>
/// <param name="maxCount">Colleciton maximum count.</param>
public CollectionStructuralDataGenerator(
IDataGenerator itemDataGenerator,
IRandomNumberGenerator random,
int minCount,
int maxCount)
{
ExceptionUtilities.CheckArgumentNotNull(itemDataGenerator, "itemDataGenerator");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
if (minCount < 0)
{
throw new TaupoArgumentException("Minimum count cannot be less than 0.");
}
ExceptionUtilities.CheckValidRange(minCount, "minCount", maxCount, "maxCount");
this.itemDataGenerator = itemDataGenerator;
this.minCount = minCount;
this.maxCount = maxCount;
this.random = random;
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
var alphabet = this.GetWordList();
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder(length);
while (sb.Length < length)
{
sb.Append(random.ChooseFrom(alphabet));
}
if (sb.Length > maxLength)
{
sb.Length = maxLength;
}
return(sb.ToString());
}
private static void AdjustTicksBasedOnFactorAndCheckRange(DataGenerationHint[] hints, ref long minTicks, ref long maxTicks, out long factor)
{
factor = GetDateTimeFactor(hints);
if (factor != 1)
{
long roundedMinTicks = (minTicks / factor) * factor;
long roundedMaxTicks = (maxTicks / factor) * factor;
if (roundedMinTicks < minTicks)
{
roundedMinTicks += factor;
}
if (roundedMaxTicks > maxTicks)
{
roundedMaxTicks -= factor;
}
minTicks = roundedMinTicks;
maxTicks = roundedMaxTicks;
}
ExceptionUtilities.CheckValidRange(minTicks, "minimum ticks based on hints", maxTicks, "maximum ticks based on hints");
}
/// <summary>
/// Binary 'FromSeed' strategy where seed is converted to byte[] representation with the length in the specified range.
/// </summary>
/// <param name="minLength">The minimum length.</param>
/// <param name="maxLength">The maximum length.</param>
/// <returns>Binary 'FromSeed' delegate.</returns>
public static Func <long, byte[]> BinaryFromSeed(int minLength, int maxLength)
{
ExceptionUtilities.CheckValidRange <int>(minLength, "minLength", maxLength, "maxLength");
return(delegate(long seed)
{
List <byte> values = new List <byte>();
seed = Math.Abs(seed);
while (values.Count < maxLength && seed > 0)
{
byte b = (byte)(seed % 256);
values.Add(b);
seed = seed / 256;
}
while (values.Count < minLength)
{
values.Add(0);
}
return values.ToArray();
});
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
int wordCount = random.NextFromRange(2, 10);
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder();
while (sb.Length < length)
{
string word = this.wordGenerator.GenerateString(random, 2, Math.Max(3, length / wordCount));
sb.Append(word);
if (sb.Length < length)
{
sb.Append(' ');
if (random.Next(100) < 30)
{
sb.Append(random.ChooseFrom(glueWords));
sb.Append(' ');
}
}
}
if (maxLength > 0 && sb.Length > maxLength - 1)
{
sb.Length = maxLength - 1;
sb.Append(".");
sb[0] = char.ToUpperInvariant(sb[0]);
}
return(sb.ToString());
}
private static TData GetNumericMaxValueAndCheckRange <TData>(DataGenerationHint[] hints, TData defaultMinValue, TData defaultMaxValue, out TData minValue)
where TData : struct, IComparable <TData>
{
// For numeric types max and min hints could be of different type,
// Example: max and min value could be int, while value type is double
List <double> minValues = new List <double>();
List <double> maxValues = new List <double>();
minValues.Add((double)Convert.ChangeType(defaultMinValue, typeof(double), CultureInfo.InvariantCulture));
maxValues.Add((double)Convert.ChangeType(defaultMaxValue, typeof(double), CultureInfo.InvariantCulture));
foreach (var hint in hints)
{
Type hintType = hint.GetType();
if (hintType.IsGenericType())
{
Type hintGenericType = hintType.GetGenericTypeDefinition();
Type valueType = hintType.GetGenericArguments()[0];
if (numericTypes.Contains(valueType))
{
List <double> listToAdd = null;
if (hintGenericType == typeof(MaxValueHint <>))
{
listToAdd = maxValues;
}
else if (hintGenericType == typeof(MinValueHint <>))
{
listToAdd = minValues;
}
// not all generic hints are min/max value, so don't assume the list was populated
if (listToAdd != null)
{
object value = hintType.GetProperty("Value").GetValue(hint, null);
listToAdd.Add((double)Convert.ChangeType(value, typeof(double), CultureInfo.InvariantCulture));
}
}
}
}
double doubleMinValue = minValues.Max();
double doubleMaxValue = maxValues.Min();
ExceptionUtilities.CheckValidRange(doubleMinValue, "minimum value from hints", doubleMaxValue, "maximum value from hints");
object convertedMinValue = WorkaroundForConvert(doubleMinValue, typeof(TData));
object convertedMaxValue = WorkaroundForConvert(doubleMaxValue, typeof(TData));
if ((double)Convert.ChangeType(convertedMinValue, typeof(double), CultureInfo.InvariantCulture) < doubleMinValue)
{
convertedMinValue = Convert.ChangeType(doubleMinValue + 1, typeof(TData), CultureInfo.InvariantCulture);
}
if ((double)Convert.ChangeType(convertedMaxValue, typeof(double), CultureInfo.InvariantCulture) > doubleMaxValue)
{
convertedMaxValue = Convert.ChangeType(doubleMaxValue - 1, typeof(TData), CultureInfo.InvariantCulture);
}
minValue = (TData)convertedMinValue;
TData maxValue = (TData)convertedMaxValue;
ExceptionUtilities.CheckValidRange(minValue, "minimum value from hints", maxValue, "maximum value from hints");
return(maxValue);
}