internal static void Find_AllSearchable(DataRandom testInstance)
{
foreach (string item in DataRandom.SupportedProperties)
{
testInstance.Find(item).Assert().IsNot(null);
}
}
/// <summary>Creates a random instance of the given type.</summary>
/// <param name="type">Type to generate.</param>
/// <param name="randomizer">Handles callback behavior for child values.</param>
/// <returns>Created instance.</returns>
private static object Create(Type type, RandomizerChainer randomizer)
{
Type newType = FindTypeToCreate(type, randomizer);
if (newType != type)
{
return(randomizer.Create(newType));
}
DataRandom smartData = randomizer.Gen.NextData();
object data = CreateNew(type, randomizer, smartData);
if (data == null)
{
return(data);
}
Type dataType = data.GetType();
foreach (FieldInfo field in dataType.GetFields(BindingFlags.Instance | BindingFlags.Public)
.Where(f => !f.IsInitOnly && !f.IsLiteral))
{
string smartValue = (field.FieldType == typeof(string))
? smartData.Find(field.Name)
: null;
field.SetValue(data, smartValue ?? randomizer.Create(field.FieldType, data));
}
foreach (PropertyInfo property in dataType.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(p => p.CanWrite)
.Where(p => p.GetSetMethod() != null))
{
string smartValue = (property.PropertyType == typeof(string))
? smartData.Find(property.Name)
: null;
property.SetValue(data, smartValue ?? randomizer.Create(property.PropertyType, data));
}
return(data);
}
/// <summary>Creates a <typeparamref name="T"/> instance.</summary>
/// <typeparam name="T">Creation method type.</typeparam>
/// <param name="randomizer">Handles callback behavior for child values.</param>
/// <param name="smartData">Predefined random data.</param>
/// <param name="invoker">How to create the type from the creation method.</param>
/// <param name="creators">Possible creation methods.</param>
/// <returns>The created instance.</returns>
private static object CreateFrom <T>(RandomizerChainer randomizer, DataRandom smartData,
Func <T, object[], object> invoker, IEnumerable <T> creators) where T : MethodBase
{
T creator = randomizer.Gen.NextItem(creators);
if (creator is MethodInfo method && method.IsGenericMethodDefinition)
{
creator = (T)(object)method.MakeGenericMethod(method
.GetGenericArguments()
.Select(a => GenericCreateHint.CreateArg(a, randomizer))
.ToArray());
}
return(invoker.Invoke(creator, creator.GetParameters()
.Select(p =>
{
string smartValue = (p.ParameterType == typeof(string))
? smartData.Find(p.Name)
: null;
return smartValue ?? randomizer.Create(p.ParameterType, randomizer.Parent);
})
.ToArray()));
}
internal static void Find_NoResultNull(DataRandom testInstance, string name)
{
testInstance.Find(name).Assert().Is(null);
}
internal static void Find_IgnoresSpecialChars(DataRandom testInstance)
{
testInstance.Find("_" + DataRandom.SupportedProperties.First()).Assert().IsNot(null);
}