private static TestClass GetTestClass(Type testClass, Type collectionType)
{
var testCollection = GetTestCollection(testClass, collectionType);
var typeInfo = new ReflectionTypeInfo(testClass);
var retval = new TestClass(testCollection, typeInfo);
return(retval);
}
internal static TestMethod CreateTestMethod(Type @class, string name)
{
var assemblyInfo = new ReflectionAssemblyInfo(@class.Assembly);
var testAssembly = new TestAssembly(assemblyInfo);
var testCollection = new TestCollection(testAssembly, null, string.Empty);
var classInfo = new ReflectionTypeInfo(@class);
var testClass = new TestClass(testCollection, classInfo);
var method = testClass.Class.GetMethods(true).First(m => m.Name == name);
var testMethod = new TestMethod(testClass, method);
return(testMethod);
}
List <MethodDefinition> AddPostInjectMethods(
TypeDefinition typeDef, TypeReference genericTypeDef, ReflectionTypeInfo typeInfo)
{
var postInjectMethods = new List <MethodDefinition>();
for (int i = 0; i < typeInfo.InjectMethods.Count; i++)
{
postInjectMethods.Add(
AddPostInjectMethod(
TypeAnalyzer.ReflectionBakingInjectMethodPrefix + i, typeInfo.InjectMethods[i], typeDef, genericTypeDef));
}
return(postInjectMethods);
}
List <MethodDefinition> AddFieldSetters(
TypeDefinition typeDef, TypeReference genericTypeDef, ReflectionTypeInfo typeInfo)
{
var methodDefs = new List <MethodDefinition>();
for (int i = 0; i < typeInfo.InjectFields.Count; i++)
{
methodDefs.Add(
AddSetterMethod(
TypeAnalyzer.ReflectionBakingFieldSetterPrefix + i,
typeInfo.InjectFields[i].FieldInfo, typeDef, genericTypeDef));
}
return(methodDefs);
}
List <MethodDefinition> AddPropertySetters(
TypeDefinition typeDef, TypeReference genericTypeDef, ReflectionTypeInfo typeInfo)
{
var methodDefs = new List <MethodDefinition>();
for (int i = 0; i < typeInfo.InjectProperties.Count; i++)
{
methodDefs.Add(
AddSetterMethod(
TypeAnalyzer.ReflectionBakingPropertySetterPrefix + i.ToString(),
typeInfo.InjectProperties[i].PropertyInfo, typeDef, genericTypeDef));
}
return(methodDefs);
}
public IEnumerable <IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions,
ITestMethod testMethod, IAttributeInfo factAttribute)
{
var result = new List <IXunitTestCase>();
var types = factAttribute.GetNamedArgument <Type[]>("Types");
foreach (var type in types)
{
var typeInfo = new ReflectionTypeInfo(type);
var genericMethodInfo = testMethod.Method.MakeGenericMethod(typeInfo);
var genericTestMethod = new GenericTestMethod(testMethod.TestClass, genericMethodInfo, typeInfo);
result.Add(
new XunitTestCase(DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(),
genericTestMethod));
}
return(result);
}
public void ReturnsCorrectCustomAttributes(Type classType, IEnumerable <string> expectedTraits)
{
var testAssembly = new TestAssembly(new ReflectionAssemblyInfo(classType.Assembly));
var testCollection = new TestCollection(testAssembly, null, "Trait inheritance tests");
var @class = new ReflectionTypeInfo(classType);
var testClass = new TestClass(testCollection, @class);
var methodInfo = new ReflectionMethodInfo(classType.GetMethod("TraitsTest") !);
var testMethod = new TestMethod(testClass, methodInfo);
var testCase = new TestableXunitTestCase(testMethod);
var testTraits = testCase.Traits["Test"];
Assert.NotNull(testTraits);
foreach (var expectedTrait in expectedTraits)
{
Assert.Contains(expectedTrait, testTraits);
}
}
void CreateGetInfoMethod(
TypeDefinition typeDef, TypeReference genericTypeDef, ReflectionTypeInfo typeInfo,
MethodDefinition factoryMethod, List <MethodDefinition> fieldSetMethods,
List <MethodDefinition> propertySetMethods, List <MethodDefinition> postInjectMethods)
{
var getInfoMethodDef = new MethodDefinition(
TypeAnalyzer.ReflectionBakingGetInjectInfoMethodName,
MethodAttributes.Private | MethodAttributes.HideBySig |
MethodAttributes.Static,
_zenjectTypeInfoType);
typeDef.Methods.Add(getInfoMethodDef);
getInfoMethodDef.CustomAttributes.Add(
new CustomAttribute(_preserveConstructor));
var returnValueVar = new VariableDefinition(_module.TypeSystem.Object);
var body = getInfoMethodDef.Body;
body.Variables.Add(returnValueVar);
body.InitLocals = true;
var instructions = new List <Instruction>();
instructions.Add(Instruction.Create(OpCodes.Ldtoken, genericTypeDef));
instructions.Add(Instruction.Create(OpCodes.Call, _getTypeFromHandleMethod));
if (factoryMethod == null)
{
instructions.Add(Instruction.Create(OpCodes.Ldnull));
}
else
{
instructions.Add(Instruction.Create(OpCodes.Ldnull));
instructions.Add(Instruction.Create(OpCodes.Ldftn, factoryMethod.ChangeDeclaringType(genericTypeDef)));
instructions.Add(Instruction.Create(OpCodes.Newobj, _funcConstructor));
}
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, typeInfo.InjectConstructor.Parameters.Count));
instructions.Add(Instruction.Create(OpCodes.Newarr, _injectableInfoType));
for (int i = 0; i < typeInfo.InjectConstructor.Parameters.Count; i++)
{
var injectableInfo = typeInfo.InjectConstructor.Parameters[i].InjectableInfo;
instructions.Add(Instruction.Create(OpCodes.Dup));
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, i));
EmitNewInjectableInfoInstructions(
instructions, injectableInfo, typeDef);
instructions.Add(Instruction.Create(OpCodes.Stelem_Ref));
}
instructions.Add(Instruction.Create(OpCodes.Newobj, _constructorInfoConstructor));
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, typeInfo.InjectMethods.Count));
instructions.Add(Instruction.Create(OpCodes.Newarr, _injectMethodInfoType));
Assert.IsEqual(postInjectMethods.Count, typeInfo.InjectMethods.Count);
for (int i = 0; i < typeInfo.InjectMethods.Count; i++)
{
var injectMethodInfo = typeInfo.InjectMethods[i];
instructions.Add(Instruction.Create(OpCodes.Dup));
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, i));
AddInjectableMethodInstructions(
instructions, injectMethodInfo, typeDef, genericTypeDef, postInjectMethods[i]);
instructions.Add(Instruction.Create(OpCodes.Stelem_Ref));
}
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, fieldSetMethods.Count + propertySetMethods.Count));
instructions.Add(Instruction.Create(OpCodes.Newarr, _injectMemberInfoType));
for (int i = 0; i < fieldSetMethods.Count; i++)
{
var injectField = typeInfo.InjectFields[i];
instructions.Add(Instruction.Create(OpCodes.Dup));
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, i));
AddInjectableMemberInstructions(
instructions,
injectField.InjectableInfo, injectField.FieldInfo.Name,
typeDef, genericTypeDef, fieldSetMethods[i]);
instructions.Add(Instruction.Create(OpCodes.Stelem_Ref));
}
for (int i = 0; i < propertySetMethods.Count; i++)
{
var injectProperty = typeInfo.InjectProperties[i];
instructions.Add(Instruction.Create(OpCodes.Dup));
instructions.Add(Instruction.Create(OpCodes.Ldc_I4, fieldSetMethods.Count + i));
AddInjectableMemberInstructions(
instructions,
injectProperty.InjectableInfo,
injectProperty.PropertyInfo.Name, typeDef, genericTypeDef,
propertySetMethods[i]);
instructions.Add(Instruction.Create(OpCodes.Stelem_Ref));
}
instructions.Add(Instruction.Create(OpCodes.Newobj, _zenjectTypeInfoConstructor));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_S, returnValueVar));
instructions.Add(Instruction.Create(OpCodes.Ret));
var processor = body.GetILProcessor();
foreach (var instruction in instructions)
{
processor.Append(instruction);
}
}
MethodDefinition TryAddFactoryMethod(
TypeDefinition typeDef, ReflectionTypeInfo typeInfo)
{
if (typeInfo.Type.GetParentTypes().Any(x => x.FullName == "UnityEngine.Component"))
{
Assert.That(typeInfo.InjectConstructor.Parameters.IsEmpty());
return(null);
}
if (typeInfo.InjectConstructor.ConstructorInfo == null)
{
// static classes, abstract types
return(null);
}
var factoryMethod = new MethodDefinition(
TypeAnalyzer.ReflectionBakingFactoryMethodName,
MethodAttributes.Private | MethodAttributes.HideBySig |
MethodAttributes.Static,
_module.TypeSystem.Object);
var p1 = new ParameterDefinition(_objectArrayType);
p1.Name = "P_0";
factoryMethod.Parameters.Add(p1);
var body = factoryMethod.Body;
body.InitLocals = true;
var processor = body.GetILProcessor();
var returnValueVar = new VariableDefinition(_module.TypeSystem.Object);
body.Variables.Add(returnValueVar);
processor.Emit(OpCodes.Nop);
Assert.IsNotNull(typeInfo.InjectConstructor);
var args = typeInfo.InjectConstructor.Parameters;
for (int i = 0; i < args.Count; i++)
{
var arg = args[i];
processor.Emit(OpCodes.Ldarg_0);
processor.Emit(OpCodes.Ldc_I4, i);
processor.Emit(OpCodes.Ldelem_Ref);
EmitCastOperation(
processor, arg.ParameterInfo.ParameterType, typeDef.GenericParameters);
}
processor.Emit(OpCodes.Newobj, _module.Import(typeInfo.InjectConstructor.ConstructorInfo));
processor.Emit(OpCodes.Stloc_0);
processor.Emit(OpCodes.Ldloc_S, returnValueVar);
processor.Emit(OpCodes.Ret);
typeDef.Methods.Add(factoryMethod);
return(factoryMethod);
}
