static void CompileSourcesAndRun(string[] sources, string extension, CompiledResultDelegate resultDelegate) {
TemporaryFile[] compiledAssemblyPaths = CompileSources(sources, extension);
using (var host = new PeReader.DefaultHost()) {
IAssembly[] loadedAssemblies = compiledAssemblyPaths.Select(pathToAssembly => {
var assembly = host.LoadUnitFrom(pathToAssembly.Path) as IAssembly;
Assert.IsNotNull(assembly);
return assembly;
}).ToArray();
IAssembly mainAssembly = loadedAssemblies.Last();
IAssembly[] referencedAssemblies = loadedAssemblies.Take(loadedAssemblies.Length - 1).ToArray();
TestCompilerResults results = new TestCompilerResults(mainAssembly, referencedAssemblies, host);
resultDelegate(results);
}
foreach (var tempFile in compiledAssemblyPaths) {
tempFile.Dispose();
}
}
static bool ImplementationOfMethodForClassMayBeMethods(TestCompilerResults compiledResults, string methodToImplementName,
string lookupClassName,
string uptoClassName,
params string[] expectedImplementationNames) {
IMethodDefinition methodToImplement = compiledResults.FindMethodWithName(methodToImplementName);
Assert.IsNotNull(methodToImplement, "Couldn't find method {0}", methodToImplementName);
ITypeDefinition lookupClass = compiledResults.FindTypeWithName(lookupClassName);
Assert.IsNotNull(lookupClass, "Couldn't find class {0}", lookupClassName);
ITypeDefinition uptoClass = compiledResults.FindTypeWithName(uptoClassName);
Assert.IsNotNull(uptoClass, "Couldn't find class {0}", uptoClassName);
IMethodDefinition[] expectedImplementations = expectedImplementationNames.Select(name => {
IMethodDefinition expectedImplementation = compiledResults.FindMethodWithName(name);
Assert.IsNotNull(expectedImplementation, "Couldn't find method {0}", name);
return expectedImplementation;
}).ToArray();
IMethodDefinition[] actualImplementations = ((IEnumerable<IMethodDefinition>)GarbageCollectHelper.Implements(lookupClass, uptoClass, methodToImplement)).ToArray();
if (expectedImplementations.Count() == actualImplementations.Count()) {
foreach (IMethodDefinition expectedImplementation in expectedImplementations) {
if (!actualImplementations.Contains(expectedImplementation)) {
return false;
}
}
}
else {
return false;
}
return true;
}
static bool ClassIsSubClassOfClass(TestCompilerResults compilerResults, ClassHierarchy hierarchy, String subClassName, String superClassName) {
ITypeDefinition subClassDefinition = compilerResults.FindTypeWithName(subClassName);
ITypeDefinition superClassDefinition = compilerResults.FindTypeWithName(superClassName);
return hierarchy.AllSubClassesOfClass(superClassDefinition).Contains(subClassDefinition);
}
static bool ImplementationOfMethodForClassIsMethod(TestCompilerResults compiledResults, string methodToImplementName,
string lookupClassName,
string uptoClassName,
string expectedImplementationName) {
return ImplementationOfMethodForClassMayBeMethods(compiledResults, methodToImplementName, lookupClassName, uptoClassName, expectedImplementationName);
}
static bool ClassDirectlySubclassesClass(TestCompilerResults compilerResults, ClassHierarchy hierarchy, String subClassName, String superClassName) {
ITypeDefinition subClassDefinition = compilerResults.FindTypeWithName(subClassName);
Assert.AreNotEqual(null, subClassDefinition, "Couldn't find definition for {0}", subClassName);
ITypeDefinition superClassDefinition = compilerResults.FindTypeWithName(superClassName);
Assert.AreNotEqual(null, superClassDefinition, "Couldn't find definition for {0}", superClassName);
return hierarchy.DirectSubClassesOfClass(superClassDefinition).Contains(subClassDefinition);
}
