internal CompoundValueProvider(
ValueProviderDictionary valueProviderDictionary,
HashSet <IKey> autoFillMapping,
IMemberSorter memberSorter,
IMetadataResolver metadataResolver,
IRandom random,
IList <IInstanceModifier> instanceModifiers,
IParameterConversionService parameterConversionService,
IFastReflectionUtility fastReflectionUtility)
{
Random = random;
_valueProviderDictionary = valueProviderDictionary;
_autoFillMapping = autoFillMapping;
_memberSorter = memberSorter;
_metadataResolver = metadataResolver;
_fastReflectionUtility = fastReflectionUtility;
_instanceFactory = new InstanceFactory(
this,
valueProviderDictionary,
_memberSorter,
_metadataResolver,
parameterConversionService,
fastReflectionUtility);
_modificationFactory = new ModificationFactory(instanceModifiers, random);
}
public BoundMetadataContext(MetadataObjectContext objectContext, IFastReflectionUtility fastReflectionUtility, IRandom random)
{
_objectContext = objectContext;
FastReflection = fastReflectionUtility;
Random = random;
TestDataGenerator = objectContext.TestDataGenerator;
}
protected internal DomainConfigurator()
: base(null)
{
_lazyValueProviderBuilder = () => ValueProviderBuilder;
_random = DefaultRandom.Instance;
_useDefaults = true;
_parameterToPropertyConversionFunc = parameterName => parameterName[0].ToString().ToUpper() + parameterName.Substring(1);
_fastReflectionUtility = new FastReflectionUtility(new DefaultMemberExtensionService());
}
internal CompoundValueProviderBuilder(IRandom random, IParameterConversionService parameterConversionService, IFastReflectionUtility fastReflectionUtility)
{
_random = random;
_parameterConversionService = parameterConversionService;
_fastReflectionUtility = fastReflectionUtility;
_valueProviderDictionary = new ValueProviderDictionary();
_autoFillMapping = new HashSet <IKey>();
_modifierList = new List <IInstanceModifier>();
_tempContainerCountMapping = new Dictionary <Type, int>();
_containerIndexMapping = new Dictionary <IKey, int>();
_metadataProviderMapping = new Dictionary <IKey, Func <MetadataObjectContext, object> >();
}
public InstanceFactory(
CompoundValueProvider compoundValueProvider,
ValueProviderDictionary valueProviderDictionary,
IMemberSorter memberSorter,
IMetadataResolver metadataResolver,
IParameterConversionService parameterConversionService,
IFastReflectionUtility fastReflectionUtility)
{
_compoundValueProvider = compoundValueProvider;
_valueProviderDictionary = valueProviderDictionary;
_memberSorter = memberSorter;
_metadataResolver = metadataResolver;
_parameterConversionService = parameterConversionService;
_fastReflectionUtility = fastReflectionUtility;
}
public AdvancedContext(
IKey key,
IMemberSorter memberSorter,
IMetadataResolver metadataResolver,
IParameterConversionService parameterConversionService,
ITestDataGeneratorAdvanced advancedTestDataGenerator,
IFastReflectionUtility fastReflectionUtility)
{
Key = key;
MemberSorter = memberSorter;
MetadataResolver = metadataResolver;
ParameterConversionService = parameterConversionService;
AdvancedTestDataGenerator = advancedTestDataGenerator;
FastReflection = fastReflectionUtility;
}
internal static IEnumerable <MemberKeyPart> ToChain(this LambdaExpression expression, IFastReflectionUtility fastReflectionUtility)
{
return(expression.Body.ToChain(fastReflectionUtility));
}
internal static IEnumerable <MemberKeyPart> ToChain(this Expression expression, IFastReflectionUtility fastReflectionUtility)
{
var memberExpression = expression as MemberExpression;
//DEBT: This is a hack to support convert statements (automatically introduced by the compiler).
if (memberExpression == null)
{
var unaryExpression = expression as UnaryExpression;
if (unaryExpression != null)
{
memberExpression = unaryExpression.Operand as MemberExpression;
}
}
if (memberExpression != null)
{
foreach (var chainKey in memberExpression.Expression.ToChain(fastReflectionUtility))
{
yield return(chainKey);
}
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo != null)
{
yield return(new MemberKeyPart(fastReflectionUtility.GetPropertyInfo(propertyInfo)));
}
var fieldInfo = memberExpression.Member as FieldInfo;
if (fieldInfo != null)
{
yield return(new MemberKeyPart(fastReflectionUtility.GetFieldInfo(fieldInfo)));
}
if (propertyInfo == null && fieldInfo == null)
{
throw new NotSupportedException(memberExpression.Member.Name + " is not a property or field, and thus not supported.");
}
}
}
public ITestDataConfigurator UseMemberExtensionService(IMemberExtensionService memberExtensionService)
{
_fastReflectionUtility = new FastReflectionUtility(memberExtensionService);
return(this);
}
public static ChainedKey FromExpression <TContainer, TMember>(Expression <Func <TContainer, TMember> > chainExpression, IFastReflectionUtility fastReflectionUtility)
{
var declaringType = typeof(TContainer);
var expressionChain = chainExpression.ToChain(fastReflectionUtility).ToList();
if (expressionChain.Count == 0)
{
throw new NotSupportedException("Empty chains / Non-member chains are not supported, please use AddProvider<T>()");
}
var chainedKey = new ChainedKey(declaringType, expressionChain);
return(chainedKey);
}
