public T Resolve(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
try
{
_nestingLimit.AddNestingFor <T>(trace);
if (!_nestingLimit.IsReachedFor <T>())
{
return(_fakeChain.Resolve(instanceGenerator, trace));
}
else
{
try
{
trace.NestingLimitReachedTryingDummy();
return(instanceGenerator.Dummy <T>(trace)); //TODO
}
catch (TargetInvocationException e)
{
return(default(T));
}
catch (MemberAccessException e)
{
return(default(T));
}
catch (ArgumentException e)
{
return(default(T));
}
}
}
finally
{
_nestingLimit.RemoveNestingFor <T>(trace);
}
}
private static object CreateGenericDelegatesForFunction(InstanceGenerator instanceGenerator, MethodInfo methodInfo,
GenerationTrace trace)
{
var fullSignatureTypes = ReturnTypeOf(methodInfo).Concat(ParameterTypes(methodInfo));
return(CreateGenericDelegatesObjectForConcreteTypes(fullSignatureTypes, WithArgumentGeneratedBy(instanceGenerator, methodInfo, trace)));
}
public object Instance(Type type, GenerationTrace trace)
{
return(_customizations.Where(c => c.AppliesTo(type)).FirstOrNothing()
.Fold(
() => _inner.Instance(type, trace, _customizations),
c => c.Generate(this, trace)));
}
public object Instance(Type type, GenerationTrace trace, GenerationCustomization[] customizations)
{
lock (_syncRoot)
{
return(_allGenerator.Instance(type, trace, customizations));
}
}
public T Instance <T>(GenerationTrace trace, GenerationCustomization[] customizations)
{
lock (_syncRoot)
{
return(_allGenerator.Instance <T>(trace, customizations));
}
}
public T Dummy <T>(GenerationTrace trace)
{
lock (_syncRoot)
{
return(_allGenerator.Dummy <T>(trace));
}
}
public T Instance <T>(GenerationTrace trace)
{
lock (_syncRoot)
{
return(_allGenerator.Instance <T>(trace));
}
}
public object Instance(Type type, GenerationTrace trace)
{
lock (_syncRoot)
{
return(_allGenerator.Instance(type, trace));
}
}
public T Value <T>(T seed, GenerationTrace trace)
{
lock (_syncRoot)
{
return(_allGenerator.Value <T>(seed, trace));
}
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var preprocessedStrings = from str in _excludedSubstrings
where !String.IsNullOrEmpty(str)
select str;
var result = _stringGenerator.GenerateInstance(instanceGenerator, trace);
var found = false;
for (int i = 0; i < 100; ++i)
{
result = _stringGenerator.GenerateInstance(instanceGenerator, trace);
if (preprocessedStrings.Any(result.Contains))
{
found = true;
break;
}
}
if (!found)
{
foreach (var excludedSubstring in _excludedSubstrings.Where(s => s != String.Empty))
{
result = result.Replace(excludedSubstring, "");
}
}
return(result);
}
public T GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var generateInstance = (T)_fallbackTypeGenerator.GenerateInstance(instanceGenerator, trace);
_fallbackTypeGenerator.CustomizeCreatedValue(generateInstance, instanceGenerator, trace);
return(generateInstance);
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
return(RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256));
}
public object NewInstanceOf(Type type, InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var typeInfo = type.GetTypeInfo();
var type1 = typeInfo.GetGenericArguments()[0];
var type2 = typeInfo.GetGenericArguments()[1];
return(_factoryMethod.Invoke(type1, type2, instanceGenerator, trace));
}
public T Apply(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
//todo think it through - should it need access to InlineGenerators?
var elementType = typeof (T).GetElementType();
var array = InlineGenerators.GetByNameAndType(nameof(InlineGenerators.Array), elementType)
.GenerateInstance(instanceGenerator, trace);
return (T)array;
}
public int GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var sequence = new IntegerSequence(_startingValue, _step, _simpleValueGenerator.GenerateInstance(instanceGenerator, trace));
var finalSequence = Maybe.OfNullable(Sequences.FirstOrDefault(s => s.Equals(sequence))).ValueOr(sequence);
Sequences.Add(finalSequence);
return(finalSequence.Next());
}
public DefaultGenerationRequest(
NestingLimit nestingLimit,
GenerationCustomization[] generationCustomizations)
{
NestingLimit = nestingLimit;
GenerationCustomizations = generationCustomizations;
Trace = new ListBasedGeneratonTrace();
}
public AbstractClassInterceptor(
CachedReturnValueGeneration cachedGeneration,
Func <Type, GenerationTrace, object> instanceSource,
GenerationTrace trace)
{
_cachedGeneration = cachedGeneration;
_instanceSource = instanceSource;
_trace = trace;
}
public IEnumerable <T> GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var list = new List <T>();
list.Add(instanceGenerator.Instance <T>(trace));
list.AddRange(_included);
list.Add(instanceGenerator.Instance <T>(trace));
return(list);
}
public static ICollection <T> AddTo <T>(ICollection <T> collection, int many,
InstanceGenerator instanceGenerator, GenerationTrace trace)
{
for (int i = 0; i < many; ++i)
{
collection.Add(instanceGenerator.Instance <T>(trace));
}
return(collection);
}
public byte GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
byte digit = _digitGenerator.GenerateInstance(instanceGenerator, trace);
while (digit == 0)
{
digit = _digitGenerator.GenerateInstance(instanceGenerator, trace);
}
return(digit);
}
public T GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
if (typeof(T).IsInterface)
{
return(ProxyGenerator.CreateInterfaceProxyWithoutTarget <T>(new ExplodingInterceptor()));
}
else
{
throw new Exception("Exploding instances can be created out of interfaces only!");
}
}
public T Apply(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var result = (T)_proxyGenerator.CreateClassProxy(
typeof(T),
_fallbackTypeGenerator.GenerateConstructorParameters(instanceGenerator, trace).ToArray(),
new AbstractClassInterceptor(_generation,
instanceGenerator.Instance, trace));
_fallbackTypeGenerator.FillFieldsAndPropertiesOf(result, instanceGenerator, trace);
return(result);
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var result = String.Empty;
while (result.Length < _length)
{
result += _stringGenerator.GenerateInstance(instanceGenerator, trace);
}
return(result.Substring(0, _length));
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var result = String.Empty;
for (var i = 0; i < _maxLength; ++i)
{
result += _charGenerator.GenerateInstance(instanceGenerator, trace);
}
return(result);
}
public List <object> GenerateAnyParameterValues(Func <Type, GenerationTrace, object> instanceGenerator,
GenerationTrace trace)
{
var constructorValues = new List <object>();
foreach (var constructorParam in _parameterTypes)
{
constructorValues.Add(instanceGenerator(constructorParam, trace));
}
return(constructorValues);
}
public T GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var latestArraysWithPossibleValues = _arrayElementPicking.For <T>();
if (!latestArraysWithPossibleValues.Contain(_possibleValues))
{
latestArraysWithPossibleValues.Add(_possibleValues);
}
return(latestArraysWithPossibleValues.PickNextElementFrom(_possibleValues));
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
string result = _alphaChar.GenerateInstance(instanceGenerator, trace).ToString(CultureInfo.InvariantCulture);
for (var i = 0; i < 5; ++i)
{
result += _digitChar.GenerateInstance(instanceGenerator, trace);
result += _alphaChar.GenerateInstance(instanceGenerator, trace);
}
return(result);
}
public T Resolve(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
if (_resolution.Applies())
{
trace.SelectedResolution(typeof(T), _resolution);
return(_resolution.Apply(instanceGenerator, trace));
}
else
{
return(_next.Resolve(instanceGenerator, trace));
}
}
//todo move substitute generator to a separate nuget project
public T GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var type = typeof(T);
var sub = Substitute.For <T>();
var methods = SmartType.For(type).GetAllPublicInstanceMethodsWithReturnValue();
foreach (var method in methods)
{
method.InvokeWithAnyArgsOn(sub, argType => instanceGenerator.Instance(argType, trace))
.ReturnsForAnyArgs(method.GenerateAnyReturnValue(returnType => instanceGenerator.Instance(returnType, trace)));
}
return(sub);
}
public T Apply(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var methodInfo = typeof(T).GetMethods().First(m => m.Name.Equals("Invoke"));
var parameters = methodInfo.GetParameters();
if (methodInfo.ReturnType != typeof(void))
{
var instance = CreateGenericDelegatesForFunction(instanceGenerator, methodInfo, trace);
return((T)(object)Delegate.CreateDelegate(typeof(T), instance, instance.GetType().GetMethod("Get" + parameters.Length)));
}
else
{
var instance = CreateGenericDelegatesForAction(methodInfo);
return((T)(object)Delegate.CreateDelegate(typeof(T), instance, instance.GetType().GetMethod("Do" + parameters.Length)));
}
}
