public static int Main(string[] args)
{
MockWeaver.InjectFakes(args[0], args.Length > 1 ? args[1] : null);
#if NO
// TODO: do the usual command line parsing. also we need to merge the prolog and call site patchers.
// call site patcher
var patcher = new CallSiteWeaver();
var fakeAssembly = AssemblyDefinition.ReadAssembly(args[0]);
var assembly = AssemblyDefinition.ReadAssembly(args[1]);
patcher.Weave(fakeAssembly, assembly, args[2]);
// mscorlib wrapper
if (args.Length != 2)
{
Console.Error.WriteLine("Usage: {0} <mscorlib path> <nsubstitute path> <target path>");
return(1);
}
var mscorlibPath = args[0];
var nsubstitutePath = args[1];
var targetPath = args[2];
var assembly = Wrapper.Wrap(mscorlibPath, nsubstitutePath);
assembly.Write(targetPath);
#endif
return(0);
}
static void AssertRecordedHookInjection(string codeToPatch, string testSource, [CallerMemberName] string testName = null)
{
var testAssemblyPath = CompileAssemblyAndCacheResult(testName, "Simple", new[] { codeToPatch, testSource });
var hookedTestAssemblyPath = Path.ChangeExtension(testAssemblyPath, ".Injected" + Path.GetExtension(testAssemblyPath));
using (var assembly = File.OpenRead(testAssemblyPath))
{
MockWeaver.InjectFakes(assembly, hookedTestAssemblyPath, Assembly.GetExecutingAssembly().Location);
Console.WriteLine("Original assembly: {0}", testAssemblyPath);
Console.WriteLine("Patched assembly: {0}", hookedTestAssemblyPath);
var patchedAssembly = Assembly.LoadFrom(hookedTestAssemblyPath);
var testType = patchedAssembly.GetType("T");
var method = testType.GetMethod("Test");
var obj = Activator.CreateInstance(testType);
var collector = new List <object[]>();
CastlePatchedInterceptorRegistry.Register(
obj,
(_, args) =>
{
collector.Add(args);
return(null);
});
method.Invoke(obj, new object[0]);
Assert.That(collector, Is.Not.Empty);
}
}
private void AssertPatchedAssembly(string testSource, Action <AssemblyDefinition> validator, [CallerMemberName] string testName = null)
{
var testAssemblyPath = CompileAssemblyAndCacheResult(testName, "AssertPatchedAssembly", new[] { testSource });
var hookedTestAssemblyPath = Path.ChangeExtension(testAssemblyPath, ".Patched" + Path.GetExtension(testAssemblyPath));
using (var assembly = File.OpenRead(testAssemblyPath))
{
MockWeaver.InjectFakes(assembly, hookedTestAssemblyPath, Assembly.GetExecutingAssembly().Location);
Console.WriteLine("Original assembly: {0}", testAssemblyPath);
Console.WriteLine("Patched assembly: {0}", hookedTestAssemblyPath);
var patchedAssembly = AssemblyDefinition.ReadAssembly(hookedTestAssemblyPath);
validator(patchedAssembly);
}
}
static void AssertHookInjection(string codeToPatch, string testName, Func <Type[], object[], object> hookFunc, object expectedValueFromHook, object[] args = null, Type[] genArgs = null)
{
CastlePatchedInterceptorRegistry.Clear();
var tree = CSharpSyntaxTree.ParseText(codeToPatch);
var code = (CompilationUnitSyntax)tree.GetRoot();
var testClass = code.Members.OfType <TypeDeclarationSyntax>().Single();
var originalMethodDeclaration = (MethodDeclarationSyntax)testClass.Members.SingleOrDefault(m => m.IsKind(SyntaxKind.MethodDeclaration));
var testAssemblyPath = CompileAssemblyAndCacheResult(testName, "Simple", new[] { codeToPatch });
var hookedTestAssemblyPath = Path.ChangeExtension(testAssemblyPath, ".Fake" + Path.GetExtension(testAssemblyPath));
using (var assembly = File.OpenRead(testAssemblyPath))
{
MockWeaver.InjectFakes(assembly, hookedTestAssemblyPath, Assembly.GetExecutingAssembly().Location);
Console.WriteLine("Original assembly: {0}", testAssemblyPath);
Console.WriteLine("Patched assembly: {0}", hookedTestAssemblyPath);
var fakedAssembly = Assembly.LoadFrom(hookedTestAssemblyPath);
var type = fakedAssembly.GetType(testClass.Identifier.Text);
if (testClass.TypeParameterList != null && testClass.TypeParameterList.Parameters.Count > 0)
{
type = fakedAssembly.GetType(testClass.Identifier.Text + "`" + testClass.TypeParameterList.Parameters.Count);
genArgs = genArgs ?? new[] { expectedValueFromHook.GetType() };
type = type.MakeGenericType(genArgs);
}
MethodInfo method;
if (originalMethodDeclaration != null)
{
method = type.GetMethod(originalMethodDeclaration.Identifier.ValueText);
}
else
{
var originalPropertyDeclaration = (PropertyDeclarationSyntax)testClass.Members.SingleOrDefault(m => m.IsKind(SyntaxKind.PropertyDeclaration));
if (originalPropertyDeclaration != null)
{
var prop = type.GetProperty(originalPropertyDeclaration.Identifier.ValueText);
method = prop.GetMethod ?? prop.SetMethod;
}
else
{
var originalEvent = (EventFieldDeclarationSyntax)testClass.Members.SingleOrDefault(m => m.IsKind(SyntaxKind.EventFieldDeclaration));
var evt = type.GetEvent(originalEvent.Declaration.Variables[0].Identifier.ValueText);
method = evt.AddMethod ?? evt.RemoveMethod;
}
}
args = args ?? new object[method.GetParameters().Length];
Action registerHook;
object obj = null;
if (method.IsStatic)
{
registerHook = () => CastlePatchedInterceptorRegistry.Register(type, hookFunc);
}
else
{
obj = Activator.CreateInstance(type);
registerHook = () => CastlePatchedInterceptorRegistry.Register(obj, hookFunc);
}
//var originalValue = method.Invoke(obj, dummyParams);
registerHook();
if (method.IsGenericMethodDefinition)
{
method = method.MakeGenericMethod(genArgs);
}
var actualValueFromHook = method.Invoke(obj, args);
if (method.ReturnType != typeof(void))
{
Assert.AreEqual(expectedValueFromHook, actualValueFromHook);
//Assert.AreNotEqual(originalValue, actualValueFromHook);
}
}
}