public void GetAssemblyPath_WithHashInDirectoryName()
{
string directoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "#HashTestPath");
string originalAssemblyPath = typeof(ReflectionUtilityTest).Assembly.Location;
string newAssemblyPath = Path.Combine(directoryPath, Path.GetFileName(originalAssemblyPath));
if (Directory.Exists(directoryPath))
{
Directory.Delete(directoryPath, true);
}
Directory.CreateDirectory(directoryPath);
try
{
File.Copy(originalAssemblyPath, newAssemblyPath);
AppDomainRunner.Run(
delegate(object[] args)
{
string directory = (string)args[0];
string assemblyPath = (string)args[1];
Assembly assembly = Assembly.LoadFile(assemblyPath);
Assert.That(Path.GetDirectoryName(assembly.Location), Is.EqualTo(directory));
Assert.That(ReflectionUtility.GetAssemblyDirectory(assembly), Is.EqualTo(directory));
},
directoryPath,
newAssemblyPath);
}
finally
{
Directory.Delete(directoryPath, true);
}
}
public void SpecificAppBase()
{
AppDomainRunner.Run(@"C:\", delegate(object[] args)
{
Assert.That(AppDomain.CurrentDomain.BaseDirectory, Is.EqualTo(@"C:\"));
});
}
public void DoesntChangeCurrentSetup()
{
string dynamicBaseBefore = AppDomain.CurrentDomain.SetupInformation.DynamicBase;
AppDomainRunner.Run(delegate { new AppDomainRunnerTest(); });
Assert.That(AppDomain.CurrentDomain.SetupInformation.DynamicBase, Is.EqualTo(dynamicBaseBefore));
}
public void ApplicationAssemblyInclusion_DependsOnAttribute()
{
string compiledAssemblyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NonApplicationMarkedAssembly.dll");
try
{
AppDomainRunner.Run(
delegate(object[] args)
{
var path = (string)args[0];
ApplicationAssemblyLoaderFilter filter = ApplicationAssemblyLoaderFilter.Instance;
Assert.That(filter.ShouldIncludeAssembly(typeof(AttributeAssemblyLoaderFilterTest).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(TestFixtureAttribute).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(ApplicationAssemblyLoaderFilter).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(object).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(Uri).Assembly), Is.True);
var assemblyCompiler = new AssemblyCompiler(@"Reflection\TypeDiscovery\TestAssemblies\NonApplicationMarkedAssembly", path,
typeof(NonApplicationAssemblyAttribute).Assembly.Location);
assemblyCompiler.Compile();
Assert.That(filter.ShouldIncludeAssembly(assemblyCompiler.CompiledAssembly), Is.False);
}, compiledAssemblyPath);
}
finally
{
if (File.Exists(compiledAssemblyPath))
{
FileUtility.DeleteAndWaitForCompletion(compiledAssemblyPath);
}
}
}
public void GetDefaultQueryFilePath_ThrowsIfNoQueryFileExists()
{
AppDomainRunner.Run(@"C:\", delegate
{
QueryConfiguration configuration = new QueryConfiguration();
configuration.GetDefaultQueryFilePath();
});
}
public void AppDomainIsCreated()
{
AppDomain current = AppDomain.CurrentDomain;
AppDomainRunner.Run(
delegate(object[] args)
{
Assert.That(AppDomain.CurrentDomain.FriendlyName, Is.EqualTo("AppDomainRunner - AppDomain"));
Assert.That(AppDomain.CurrentDomain, Is.Not.SameAs(args[0]));
},
current);
}
public void ArgumentsArePassedInCorrectly()
{
AppDomainRunner.Run(delegate(object[] args)
{
Assert.That(args.Length, Is.EqualTo(2));
Assert.That("Foo", Is.EqualTo(args[0]));
Assert.That(4, Is.EqualTo(args[1]));
}, "Foo", 4);
AppDomainRunner.Run(delegate(object[] args)
{
Assert.That(args.Length, Is.EqualTo(0));
});
}
public void FindAssemblies_FindsReferencedAssemblies_Transitive()
{
const string buildOutputDirectory = "Reflection.AssemblyFinderTest.FindAssemblies_FindsReferencedAssemblies_Transitive";
const string sourceDirectoryRoot = @"Reflection\TypeDiscovery\AssemblyFinding\TestAssemblies\AssemblyFinderTest";
Action <object[]> testAction = delegate(object[] args)
{
var outputManagerWithoutClosure = (AssemblyCompilerBuildOutputManager)args[0];
// dependency chain: mixinSamples -> remotion -> log4net
var log4NetAssembly = typeof(log4net.LogManager).Assembly;
var remotionAssembly = typeof(AssemblyFinder).Assembly;
var referencingAssembly = CompileReferencingAssembly(outputManagerWithoutClosure, remotionAssembly);
var loaderMock = MockRepository.GenerateMock <IAssemblyLoader>();
loaderMock
.Expect(mock => mock.TryLoadAssembly(ArgReferenceMatchesDefinition(remotionAssembly), Arg.Is(referencingAssembly.FullName)))
// load re-motion via samples
.Return(remotionAssembly);
loaderMock
.Expect(mock => mock.TryLoadAssembly(ArgReferenceMatchesDefinition(log4NetAssembly), Arg.Is(remotionAssembly.FullName)))
// load log4net via re-motion
.Return(log4NetAssembly);
loaderMock.Replay();
var rootAssemblyFinderStub = MockRepository.GenerateMock <IRootAssemblyFinder>();
rootAssemblyFinderStub.Stub(stub => stub.FindRootAssemblies()).Return(
new[] { new RootAssembly(referencingAssembly, true) });
rootAssemblyFinderStub.Replay();
var finder = new AssemblyFinder(rootAssemblyFinderStub, loaderMock);
var result = finder.FindAssemblies();
loaderMock.VerifyAllExpectations();
Assert.That(result, Is.EquivalentTo(new[] { referencingAssembly, remotionAssembly, log4NetAssembly }));
};
// Run test action in separate AppDomain
using (var outputManager = new AssemblyCompilerBuildOutputManager(buildOutputDirectory, true, sourceDirectoryRoot))
{
AppDomainRunner.Run(testAction, outputManager);
}
}
public void SavesMixedTypes()
{
AppDomainRunner.Run(
delegate
{
using (MixinConfiguration.BuildNew()
.ForClass <BaseType1>().AddMixins(typeof(BT1Mixin1))
.ForClass <Page> ().AddMixin(typeof(NullMixin))
.EnterScope())
{
Mixer mixer = Mixer.Create("Assembly", _assemblyOutputDirectory, 1);
mixer.PrepareOutputDirectory();
mixer.Execute(MixinConfiguration.ActiveConfiguration);
Assembly theAssembly = Assembly.LoadFile(mixer.MixerPipelineFactory.GetModulePaths(_assemblyOutputDirectory).Single());
var types = theAssembly.GetTypes();
var concreteType = types.SingleOrDefault(t => t.BaseType == typeof(BaseType1));
Assert.NotNull(concreteType);
Assert.That(
MixinTypeUtility.GetClassContextForConcreteType(concreteType),
Is.EqualTo(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1))));
object instance = Activator.CreateInstance(concreteType);
Assert.That(Mixin.Get <BT1Mixin1> (instance), Is.Not.Null);
var concreteTypeFromSystemAssembly = types.SingleOrDefault(t => t.BaseType == typeof(Page));
Assert.That(concreteTypeFromSystemAssembly, Is.Not.Null);
SafeServiceLocator.Current.GetInstance <IPipelineRegistry>().DefaultPipeline.CodeManager.LoadFlushedCode(theAssembly);
Type concreteTypeFromFactory = TypeFactory.GetConcreteType(typeof(BaseType1));
Assert.That(concreteTypeFromFactory, Is.SameAs(concreteType));
Assert.That(theAssembly.IsDefined(typeof(NonApplicationAssemblyAttribute), false), Is.True);
}
});
}
public void TypesFromRunnerBaseAssemblyCanBeAccessed_EvenWithDifferentBaseDirectory()
{
AppDomainRunner.Run(@"c:\", delegate { Dev.Null = typeof(AppDomainRunnerBase); });
}
public void TypesFromCurrentAssemblyCanBeAccessed_EvenWithDifferentBaseDirectory()
{
AppDomainRunner.Run(@"c:\", delegate { new AppDomainRunnerTest(); });
}
public void TypesFromCurrentAssemblyCanBeAccessed()
{
AppDomainRunner.Run(delegate { new AppDomainRunnerTest(); });
}
