public FieldToPropertyForwarder(ModuleWeaver moduleWeaver, FieldToPropertyConverter fieldToPropertyConverter, MsCoreReferenceFinder msCoreReferenceFinder, MethodFinder methodFinder)
{
this.moduleWeaver = moduleWeaver;
this.msCoreReferenceFinder = msCoreReferenceFinder;
this.methodFinder = methodFinder;
forwardedFields = fieldToPropertyConverter.ForwardedFields;
}
public WeaverHelper(string assemblyToProcess)
{
var assemblyFolder = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
BeforeAssemblyPath = Path.Combine(assemblyFolder, assemblyToProcess);
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, new ReaderParameters());
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
LogDebug = s => System.Diagnostics.Debug.WriteLine(s, "Debug"),
LogInfo = s => System.Diagnostics.Debug.WriteLine(s, "Info"),
LogWarning = s => System.Diagnostics.Debug.WriteLine(s, "Warning"),
LogError = s => System.Diagnostics.Debug.WriteLine(s, "Error"),
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath);
//ProvideIlStepThrough(AfterAssemblyPath);
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public void False()
{
var xElement = XElement.Parse("<PropertyChanged InjectOnPropertyNameChanging='false'/>");
var moduleWeaver = new ModuleWeaver { Config = xElement };
moduleWeaver.ResolveOnPropertyNameChangingConfig();
Assert.IsFalse(moduleWeaver.InjectOnPropertyNameChanging);
}
public WithIncludesTests()
{
beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory,@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "3.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(beforeAssemblyPath)
};
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath,new ReaderParameters
{
AssemblyResolver = assemblyResolver
});
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
IncludeNamespaces = new List<string>{"MyNameSpace"},
LogWarning =s => warnings.Add(s)
};
weavingTask.Execute();
moduleDefinition.Write(afterAssemblyPath);
assembly = Assembly.LoadFile(afterAssemblyPath);
}
public ExistingTests()
{
beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyToProcessExistingAttribute\bin\Debug\AssemblyToProcessExistingAttribute.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath);
var currentDirectory = AssemblyLocation.CurrentDirectory();
var moduleWeaver = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AddinDirectoryPath = currentDirectory,
SolutionDirectoryPath = currentDirectory,
AssemblyFilePath = afterAssemblyPath,
};
moduleWeaver.Execute();
moduleDefinition.Write(afterAssemblyPath);
moduleWeaver.AfterWeaving();
assembly = Assembly.LoadFile(afterAssemblyPath);
}
public static Assembly WeaveAssembly()
{
var projectPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\AssemblyToProcess\AssemblyToProcess.csproj"));
var assemblyPath = Path.Combine(Path.GetDirectoryName(projectPath), @"bin\Debug\AssemblyToProcess.dll");
var springBinPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\Fody\bin\debug\"));
#if (!DEBUG)
assemblyPath = assemblyPath.Replace("Debug", "Release");
springBinPath = springBinPath.Replace("Debug", "Release");
#endif
var newAssembly = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssembly, true);
var moduleDefinition = ModuleDefinition.ReadModule(newAssembly);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
return Assembly.LoadFile(newAssembly);
}
public AssemblyWeaver(string assemblyPath, List<string> referenceAssemblyPaths = null)
{
if (referenceAssemblyPaths == null)
{
referenceAssemblyPaths = new List<string>();
}
assemblyPath = FixAssemblyPath(assemblyPath);
var newAssembly = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssembly, true);
var assemblyResolver = new MockAssemblyResolver();
foreach (var referenceAssemblyPath in referenceAssemblyPaths)
{
var directoryName = Path.GetDirectoryName(referenceAssemblyPath);
assemblyResolver.AddSearchDirectory(directoryName);
}
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver
};
var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
LogError = LogError,
ReferenceCopyLocalPaths = referenceAssemblyPaths
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
Assembly = Assembly.LoadFrom(newAssembly);
}
public static Assembly WeaveAssembly()
{
string configurationName = "Release";
#if DEBUG
configurationName = "Debug";
#endif
string assemblyPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\AssemblyToProcess\bin", configurationName, "AssemblyToProcess.dll"));
string newAssembly = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssembly, true);
ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(newAssembly);
ModuleWeaver weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
return Assembly.LoadFile(newAssembly);
}
public void IncludeAndExcludeNamespacesAttribute()
{
var xElement = XElement.Parse(@"
<Virtuosity IncludeNamespaces='Bar' ExcludeNamespaces='Foo'/>");
var moduleWeaver = new ModuleWeaver { Config = xElement };
moduleWeaver.ReadConfig();
}
protected ProcessAssemblyBaseTest( string relativePath )
{
BeforeAssemblyPath = Path.GetFullPath( relativePath );
#if !DEBUG
BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release");
#endif
AfterAssemblyPath = BeforeAssemblyPath.Replace( ".dll", "2.dll" );
File.Copy( BeforeAssemblyPath, AfterAssemblyPath, true );
var moduleDefinition = ModuleDefinition.ReadModule( AfterAssemblyPath );
var currentDirectory = AssemblyLocation.CurrentDirectory();
PersistentInfo = PersistentInfo.LoadFromPath( currentDirectory );
StandardInfo = new StandardInfo( PersistentInfo, moduleDefinition );
var moduleWeaver = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AddinDirectoryPath = currentDirectory,
SolutionDirectoryPath = currentDirectory,
AssemblyFilePath = AfterAssemblyPath,
};
moduleWeaver.Execute();
moduleDefinition.Write( AfterAssemblyPath );
moduleWeaver.AfterWeaving();
AfterAssembly = Assembly.LoadFile( AfterAssemblyPath );
}
public IntegrationTests()
{
beforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll");
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(beforeAssemblyPath)
};
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath,new ReaderParameters
{
AssemblyResolver = assemblyResolver
});
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
};
weavingTask.Execute();
moduleDefinition.Write(afterAssemblyPath);
assembly = Assembly.LoadFile(afterAssemblyPath);
}
public WeaverHelper(string projectPath)
{
this.projectPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\TestAssemblies", projectPath));
GetAssemblyPath();
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true);
var assemblyResolver = new TestAssemblyResolver(BeforeAssemblyPath, this.projectPath);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver
};
var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath);
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
static AssemblyWeaver()
{
BeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll");
BeforeAssemblyPathSymbols = Path.ChangeExtension(BeforeAssemblyPath, "pdb");
#if (!DEBUG)
BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release");
BeforeAssemblyPathSymbols = BeforeAssemblyPathSymbols.Replace("Debug", "Release");
#endif
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
AfterAssemblyPathSymbols = Path.ChangeExtension(AfterAssemblyPath, "pdb");
File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true);
File.Copy(BeforeAssemblyPathSymbols, AfterAssemblyPathSymbols, true);
var assemblyResolver = new MockAssemblyResolver();
var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, new ReaderParameters { ReadSymbols = true });
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
LogError = LogError,
LogInfo = LogInfo,
DefineConstants = new[] { "DEBUG" }, // Always testing the debug weaver
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath, new WriterParameters { WriteSymbols = true });
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public IntegrationTests()
{
beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = new MockAssemblyResolver(),
LogWarning = s => warnings.Add(s),
LogError = s => errors.Add(s),
HideObsoleteMembers = true
};
weavingTask.Execute();
moduleDefinition.Write(afterAssemblyPath);
assembly = Assembly.LoadFile(afterAssemblyPath);
}
public void TrueHideObsoleteMembers()
{
var xElement = XElement.Parse(@"<Obsolete HideObsoleteMembers='true'/>");
var moduleWeaver = new ModuleWeaver {Config = xElement};
moduleWeaver.ReadConfig();
Assert.IsTrue(moduleWeaver.HideObsoleteMembers);
}
public void ThrowsNotImplementedText()
{
var xElement = XElement.Parse(@"<Obsolete ThrowsNotImplementedText='Custom Text'/>");
var moduleWeaver = new ModuleWeaver {Config = xElement};
moduleWeaver.ReadConfig();
Assert.AreEqual("Custom Text", moduleWeaver.ThrowsNotImplementedText);
}
public void VersionIncrementThrows()
{
var xElement = XElement.Parse(@"<Obsolete VersionIncrement='1.0.1'/>");
var moduleWeaver = new ModuleWeaver {Config = xElement};
var exception = Assert.Throws<WeavingException>(moduleWeaver.ReadConfig);
Assert.AreEqual("VersionIncrement is no longer supported. Use StepType instead.", exception.Message);
}
public void CanParseStepType()
{
var xElement = XElement.Parse(@"<Obsolete StepType='Minor'/>");
var moduleWeaver = new ModuleWeaver {Config = xElement};
moduleWeaver.ReadConfig();
Assert.AreEqual(StepType.Minor, moduleWeaver.StepType);
}
public ModuleWeaverOperandTests()
{
var beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
var afterAssemblyPath = typeof(ModuleWeaverOperandTests).Name + ".dll";
var moduleDefinition = ModuleDefinition.ReadModule(beforeAssemblyPath);
AddConditionalBranchLong(moduleDefinition, moduleDefinition.Types.Single(t => t.Name == "TargetClass"));
// Offset assignment happens on write
// Having offsets assigned prior to weaving makes tracking down bugs easier
moduleDefinition.Write(afterAssemblyPath);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
};
weavingTask.Execute();
moduleDefinition.Assembly.Name.Name += "ForOperand";
moduleDefinition.Write(afterAssemblyPath);
var assembly = Assembly.LoadFrom(afterAssemblyPath);
var type = assembly.GetType("TargetClass", true);
targetClass = Activator.CreateInstance(type);
}
public PropertyWeaver(ModuleWeaver moduleWeaver, PropertyData propertyData, TypeNode typeNode, TypeSystem typeSystem )
{
this.moduleWeaver = moduleWeaver;
this.propertyData = propertyData;
this.typeNode = typeNode;
this.typeSystem = typeSystem;
}
public TaskTests()
{
beforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll");
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath);
var currentDirectory = AssemblyLocation.CurrentDirectory();
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AddinDirectoryPath = currentDirectory,
SolutionDirectoryPath = currentDirectory,
AssemblyFilePath = afterAssemblyPath,
SvnHelper = new MockSvnHelper(),
};
weavingTask.Execute();
moduleDefinition.Write(afterAssemblyPath);
weavingTask.AfterWeaving();
assembly = Assembly.LoadFile(afterAssemblyPath);
}
public void False()
{
var xElement = XElement.Parse("<PropertyChanged CheckForEquality='false'/>");
var moduleWeaver = new ModuleWeaver { Config = xElement };
moduleWeaver.ResolveCheckForEqualityConfig();
Assert.IsFalse(moduleWeaver.CheckForEquality);
}
public void Simple()
{
var beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyWithExcludes\bin\Debug\AssemblyWithExcludes.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
var afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
ExcludeNamespaces = new List<string> { "ExcludeNamespace"}
};
weavingTask.Execute();
moduleDefinition.Write(afterAssemblyPath);
var assembly = Assembly.LoadFile(afterAssemblyPath);
var excludeType = assembly.GetType("ExcludeNamespace.ExcludeClass");
Assert.IsFalse(excludeType.GetMethod("Method").IsVirtual);
var includeType = assembly.GetType("IncludeNamespace.IncludeClass");
Assert.IsTrue(includeType.GetMethod("Method").IsVirtual);
var inNamespaceButWithAttributeType = assembly.GetType("IncludeNamespace.InNamespaceButWithAttributeClass");
Assert.IsFalse(inNamespaceButWithAttributeType.GetMethod("Method").IsVirtual);
var notInNamespaceButWithAttributeType = assembly.GetType("ExcludeNamespace.NotInNamespaceButWithAttributeClass");
Assert.IsFalse(notInNamespaceButWithAttributeType.GetMethod("Method").IsVirtual);
#if(DEBUG)
Verifier.Verify(beforeAssemblyPath, afterAssemblyPath);
#endif
}
public void True()
{
var xElement = XElement.Parse("<PropertyChanged InjectOnPropertyNameChanged='true'/>");
var moduleWeaver = new ModuleWeaver {Config = xElement};
moduleWeaver.ResolveOnPropertyNameChangedConfig();
Assert.IsTrue(moduleWeaver.InjectOnPropertyNameChanged);
}
public void VerifyAssembly(string assemblyPath)
{
Debug.WriteLine("Verifying " + assemblyPath);
var cleanAssembly = assemblyPath.Replace(".dll", "2.dll");
var newAssembly = assemblyPath.Replace(".dll", "3.dll");
File.Copy(assemblyPath, cleanAssembly, true);
File.Copy(assemblyPath, newAssembly, true);
var assemblyResolver = new MockAssemblyResolver();
var moduleDefinition = ModuleDefinition.ReadModule(cleanAssembly);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
};
moduleDefinition.Write(cleanAssembly);
moduleDefinition = ModuleDefinition.ReadModule(newAssembly);
weavingTask.ModuleDefinition = moduleDefinition;
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
Verifier.Verify(cleanAssembly, newAssembly);
}
public void Setup()
{
var projectPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\AssemblyToProcess\AssemblyToProcess.csproj"));
assemblyPath = Path.Combine(Path.GetDirectoryName(projectPath), @"bin\Debug\AssemblyToProcess.dll");
#if (!DEBUG)
assemblyPath = assemblyPath.Replace("Debug", "Release");
#endif
newAssemblyPath = assemblyPath.Replace(".dll", "2.dll");
shadowAssemblyPath = assemblyPath.Replace(".dll", "2shadow.dll");
File.Copy(assemblyPath, newAssemblyPath, true);
File.Copy(assemblyPath, shadowAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(newAssemblyPath);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition
};
weavingTask.Execute();
moduleDefinition.Write(newAssemblyPath);
assembly = Assembly.LoadFile(newAssemblyPath);
}
public static string Weave(string assemblyPath)
{
var newAssembly = assemblyPath.Replace(".dll", "2.dll");
var oldPdb = assemblyPath.Replace(".dll", ".pdb");
var newPdb = assemblyPath.Replace(".dll", "2.pdb");
File.Copy(assemblyPath, newAssembly, true);
File.Copy(oldPdb, newPdb, true);
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(assemblyPath)
};
using (var symbolStream = File.OpenRead(newPdb))
{
var readerParameters = new ReaderParameters
{
ReadSymbols = true,
SymbolStream = symbolStream,
SymbolReaderProvider = new PdbReaderProvider()
};
var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
return newAssembly;
}
}
protected static string WeaveAssembly(Type assemblyType)
{
var normalizedPath = assemblyType.Assembly.CodeBase.Replace(@"file:///", string.Empty);
var weaver = new ModuleWeaver();
return WeavedAssemblyPath = weaver.WeaveToShadowFile(normalizedPath);
}
public void VerifyRefError()
{
var errors = new List<string>();
var assemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyToProcessWithErrors\bin\Debug\AssemblyToProcessWithErrors.dll"));
#if (!DEBUG)
assemblyPath = assemblyPath.Replace("Debug", "Release");
#endif
var moduleDefinition = ModuleDefinition.ReadModule(assemblyPath, new ReaderParameters
{
//SymbolStream = symbolStream,
ReadSymbols = true
});
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
LogErrorPoint = (s, p) => errors.Add(s)
};
weavingTask.Execute();
Assert.Contains("Method 'ClassUsingOutParam.Method' uses member 'ClassWithField.Member' as a 'ref' or 'out' parameter. This is not supported by Fielder. Please convert this field to a property manually.", errors);
Assert.Contains("Method 'ClassUsingRefParam.Method' uses member 'ClassWithField.Member' as a 'ref' or 'out' parameter. This is not supported by Fielder. Please convert this field to a property manually.", errors);
Assert.AreEqual(2, errors.Count);
}
public ModuleWeaverOrdinalTests()
{
beforeAssemblyPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"));
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
#if (!DEBUG)
beforeAssemblyPath = beforeAssemblyPath.Replace("Debug", "Release");
#endif
afterAssemblyPath = beforeAssemblyPath.Replace(".dll", "3.dll");
File.Copy(beforeAssemblyPath, afterAssemblyPath, true);
var moduleDefinition = ModuleDefinition.ReadModule(afterAssemblyPath);
var weavingTask = new ModuleWeaver
{
Config = XElement.Parse(@"<Caseless StringComparison="" ordinal ""/>"),
ModuleDefinition = moduleDefinition,
};
weavingTask.Execute();
moduleDefinition.Assembly.Name.Name += "ForOrdinal";
moduleDefinition.Write(afterAssemblyPath);
var assembly = Assembly.LoadFrom(afterAssemblyPath);
var type = assembly.GetType("TargetClass", true);
targetClass = Activator.CreateInstance(type);
}
public MethodWeaverHelper(ModuleWeaver moduleWeaver)
{
ModuleWeaver = moduleWeaver;
ModuleDefinition = moduleWeaver.ModuleDefinition;
}
static ModuleWeaverTests()
{
var weavingTask = new ModuleWeaver();
TestResult = weavingTask.ExecuteTestRun("InlineMethod.Tests.AssemblyToProcess.dll");
}
static WithNopInterceptorTests()
{
var weavingTask = new ModuleWeaver();
testResult = weavingTask.ExecuteTestRun("AssemblyWithNopInterceptor.dll");
}
private static void WeaveAssembly(Type type, ModuleWeaver weaver)
{
var normalizedPath = type.Assembly.CodeBase.Replace(@"file:///", string.Empty);
WeavedAssemblyPath = weaver.WeaveToShadowFile(normalizedPath, ModuleHelper.AssemblyResolver);
}
public OperatorBadCaseIntegrationTests()
{
weavingTask = new ModuleWeaver();
}
static AssemblyWeaver()
{
var testDirectory = TestContext.CurrentContext.TestDirectory;
BeforeAssemblyPath = Path.GetFullPath(Path.Combine(testDirectory, @"..\..\..\..\AssemblyToProcess\bin\Debug\net452\AssemblyToProcess.dll"));
BeforeSymbolPath = Path.ChangeExtension(BeforeAssemblyPath, "pdb");
#if (!DEBUG)
BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release");
BeforeSymbolPath = BeforeSymbolPath.Replace("Debug", "Release");
#endif
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
AfterSymbolPath = BeforeSymbolPath.Replace(".pdb", "2.pdb");
if (File.Exists(AfterAssemblyPath))
{
File.Delete(AfterAssemblyPath);
}
if (File.Exists(AfterSymbolPath))
{
File.Delete(AfterSymbolPath);
}
var assemblyResolver = new MockAssemblyResolver();
var readerParameters = new ReaderParameters {
AssemblyResolver = assemblyResolver
};
var writerParameters = new WriterParameters();
if (File.Exists(BeforeSymbolPath))
{
readerParameters.ReadSymbols = true;
readerParameters.SymbolReaderProvider = new PdbReaderProvider();
readerParameters.SymbolStream = new FileStream(BeforeSymbolPath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
writerParameters.WriteSymbols = true;
writerParameters.SymbolWriterProvider = new PdbWriterProvider();
}
var moduleDefinition = ModuleDefinition.ReadModule(BeforeAssemblyPath, readerParameters);
var weavingTask = new ModuleWeaver
{
Config = new XElement("NullGuard",
new XAttribute("IncludeDebugAssert", false),
new XAttribute("ExcludeRegex", "^ClassToExclude$")),
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
LogInfo = LogInfo,
LogWarn = LogWarn,
LogError = LogError,
DefineConstants = new List <string> {
"DEBUG"
} // Always testing the debug weaver
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath, writerParameters);
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public AssemblyWeaver(List <string> referenceAssemblyPaths = null)
{
if (referenceAssemblyPaths is null)
{
referenceAssemblyPaths = new List <string>();
}
//Force ref since MSTest is a POS
var type = typeof(ViewModelBaseTest);
BeforeAssemblyPath = type.GetAssemblyEx().Location;
//BeforeAssemblyPath = Path.GetFullPath("Catel.Fody.TestAssembly.dll");
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
var oldPdb = Path.ChangeExtension(BeforeAssemblyPath, "pdb");
var newPdb = Path.ChangeExtension(AfterAssemblyPath, "pdb");
if (File.Exists(oldPdb))
{
File.Copy(oldPdb, newPdb, true);
}
Debug.WriteLine("Weaving assembly on-demand from '{0}' to '{1}'", BeforeAssemblyPath, AfterAssemblyPath);
var assemblyResolver = new TestAssemblyResolver();
//assemblyResolver.AddSearchDirectory(AssemblyDirectoryHelper.GetCurrentDirectory());
//foreach (var referenceAssemblyPath in referenceAssemblyPaths)
//{
// var directoryName = Path.GetDirectoryName(referenceAssemblyPath);
// assemblyResolver.AddSearchDirectory(directoryName);
//}
var metadataResolver = new MetadataResolver(assemblyResolver);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver,
MetadataResolver = metadataResolver,
ReadSymbols = File.Exists(oldPdb),
};
using (var moduleDefinition = ModuleDefinition.ReadModule(BeforeAssemblyPath, readerParameters))
{
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyFilePath = AfterAssemblyPath,
AssemblyResolver = assemblyResolver,
Config = XElement.Parse(@"<Weavers><Catel /></Weavers>"),
AddinDirectoryPath = Path.Combine(AssemblyDirectoryHelper.GetCurrentDirectory(), "..", "..", "Catel.Fody")
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath);
}
// if (Debugger.IsAttached)
// {
//#if DEBUG
// var output = "debug";
//#else
// var output = "release";
//#endif
// var targetFile = $@"C:\Source\Catel.Fody\output\{output}\Catel.Fody.Tests\Catel.Fody.TestAssembly2.dll";
// var targetDirectory = Path.GetDirectoryName(targetFile);
// Directory.CreateDirectory(targetDirectory);
// File.Copy(AfterAssemblyPath, targetFile, true);
// }
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public ReferenceSelector(ModuleWeaver moduleWeaver, ModuleDefinition moduleDefinition, Configuration configuration)
{
_moduleWeaver = moduleWeaver;
_moduleDefinition = moduleDefinition;
_configuration = configuration;
}
public WeaverLogger(ModuleWeaver weaver)
{
_weaver = weaver ?? throw new ArgumentNullException(nameof(weaver));
}
static BindableTests()
{
var weavingTask = new ModuleWeaver();
__testResult = weavingTask.ExecuteTestRun("AssemblyToProcess.dll", runPeVerify: false);
}
public static void InterceptConstructors(Builder builder)
{
if (!constructorInterceptionAttributes.Any())
{
return;
}
var constructors = builder
.FindMethodsByAttributes(constructorInterceptionAttributes)
.Where(x => !x.Method.OriginType.IsInterface)
.GroupBy(x => new MethodKey(x.Method, null))
.Select(x => new MethodBuilderInfo <MethodBuilderInfoItem <BuilderTypeIConstructorInterceptor> >(x.Key, x.Select(y => new MethodBuilderInfoItem <BuilderTypeIConstructorInterceptor>(y, BuilderTypes.IConstructorInterceptor))))
.ToArray();
foreach (var constructor in constructors)
{
if (constructor.Items == null || constructor.Items.Length == 0)
{
continue;
}
var targetedConstrutor = constructor.Key.Method;
if (!targetedConstrutor.IsCtor && !targetedConstrutor.IsCCtor)
{
continue;
}
builder.Log(LogTypes.Info, $"Implementing constructors interceptors: {constructor.Key.Method.DeclaringType.Name.PadRight(40, ' ')} {constructor.Key.Method.Name}({string.Join(", ", constructor.Key.Method.Parameters.Select(x => x.Name))})");
if (constructor.RequiresSyncRootField)
{
builder.Log(LogTypes.Warning, targetedConstrutor, $"An interceptor applied to the constructor has implemented ISyncRoot. This is not supported. The interceptor may not work correctly.");
}
CodeBlock parametersArray = null;
var localVariables = new LocalVariable[constructor.Items.Length];
Coder InterceptorInit(Coder contextCoder, bool isBeforeInit)
{
parametersArray = contextCoder.GetParametersArray();
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
localVariables[i] = contextCoder.AssociatedMethod.GetOrCreateVariable(item.Interface.BuilderType);
contextCoder.SetValue(localVariables[i], x => x.NewObj(item.Attribute));
contextCoder.Load(localVariables[i]).Call(item.Interface.GetMethod_OnBeforeInitialization(), targetedConstrutor.OriginType, targetedConstrutor, parametersArray);
item.Attribute.Remove();
}
return(contextCoder);
}
if (targetedConstrutor.IsCtor)
{
targetedConstrutor.NewCoder()
.Context(x => InterceptorInit(x, true))
.Insert(InsertionPosition.CtorBeforeInit);
}
targetedConstrutor.NewCoder()
.Context(x =>
{
if (targetedConstrutor.IsCCtor)
{
InterceptorInit(x, false);
}
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
ModuleWeaver.ImplementAssignMethodAttribute(builder, item.AssignMethodAttributeInfos, localVariables[i], item.Attribute.Attribute.Type, x);
item.Attribute.Remove();
}
return(x);
})
.Try(x =>
{
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
x.Load(localVariables[i]).Call(item.Interface.GetMethod_OnEnter(), targetedConstrutor.OriginType, CodeBlocks.This, targetedConstrutor, parametersArray);
}
return(x);
})
.Catch(BuilderTypes.Exception.BuilderType, (ex, e) =>
{
return(ex.If(x => x.Or(constructor.Items, (coder, y, i) => coder.Load(localVariables[i]).Call(y.Interface.GetMethod_OnException(), e())).Is(true),
then => ex.NewCoder().Rethrow())
.DefaultValue()
.Return());
})
.Finally(x =>
{
for (int i = 0; i < constructor.Items.Length; i++)
{
x.Load(localVariables[i]).Call(constructor.Items[i].Interface.GetMethod_OnException());
}
return(x);
})
.EndTry()
.Return()
.Replace();
}
}
public void When_assembly_to_weave_does_not_reference_equals_assembly_weaving_should_not_fail()
{
var testResult = new ModuleWeaver().ExecuteTestRun("AssemblyToProcessWithoutReference.dll");
Assert.NotNull(testResult.GetInstance("Foo"));
}
public TestResult GetAssembly(string testCaseName, string configString)
{
if (!_assemblies.ContainsKey(configString))
{
var type = typeof(DummyDependencyInjectionClass);
var assemblyPath = type.GetAssemblyEx().Location;
var rootDirectory = Directory.GetParent(assemblyPath).FullName;
var testCaseDirectory = Path.Combine(rootDirectory, testCaseName);
Directory.CreateDirectory(testCaseDirectory);
var assemblyResolver = new TestAssemblyResolver();
//assemblyResolver.AddSearchDirectory(testCaseDirectory);
//assemblyResolver.AddSearchDirectory(rootDirectory);
var metadataResolver = new MetadataResolver(assemblyResolver);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver,
MetadataResolver = metadataResolver,
ReadSymbols = false,
};
using (var moduleDefinition = ModuleDefinition.ReadModule(assemblyPath, readerParameters))
{
// Important note: the test project can be on a completely different location (especially on a build agent)
var projectName = Path.GetFileName(assemblyPath).Replace(".dll", string.Empty);
// Check 1: fixed location from test
var relativeCsProjectFilePath = Path.Combine(Directory.GetParent(assemblyPath).FullName, "..", "..", "..", "..", "src", projectName, $"{projectName}.csproj");
var csProjectFilePath = Path.GetFullPath(relativeCsProjectFilePath);
if (!File.Exists(csProjectFilePath))
{
// Check 2: Check 2 directories up, then search for the project file (happens on a build agent)
var searchDirectory = Path.Combine(Directory.GetParent(assemblyPath).FullName, "..", "..", "..", "Source");
var searchFileName = $"{projectName}.csproj";
csProjectFilePath = Directory.GetFiles(searchDirectory, searchFileName, SearchOption.AllDirectories).FirstOrDefault();
}
if (!File.Exists(csProjectFilePath))
{
throw new System.Exception($"Project file '{csProjectFilePath}' does not exist, make sure to check the paths since this is required for the unit tests");
}
var references = new string[]
{
//"Catel.Core.dll",
//"Orc.FileSystem.dll"
};
var weavingTask = new ModuleWeaver
{
Config = XElement.Parse(configString),
AssemblyResolver = assemblyResolver,
ProjectFilePath = csProjectFilePath,
ModuleDefinition = moduleDefinition,
References = string.Join(";", references.Select(r => Path.Combine(rootDirectory, r))),
ReferenceCopyLocalPaths = references.Select(r => Path.Combine(rootDirectory, r)).ToList(),
};
var testResult = weavingTask.ExecuteTestRun(assemblyPath,
assemblyName: testCaseName,
ignoreCodes: new[] { "0x80131869" },
runPeVerify: false);
if (testResult.Errors.Count > 0)
{
throw new System.Exception("Received errors while weaving");
}
_assemblies[configString] = testResult;
}
}
return(_assemblies[configString]);
}
public MsCoreReferenceFinder(ModuleWeaver moduleWeaver, IAssemblyResolver assemblyResolver)
{
this._moduleWeaver = moduleWeaver;
}
public void SetUp()
{
stackOverflowChecker = new ModuleWeaver();
}
public static void InterceptMethods(Builder builder)
{
if (!methodInterceptionAttributes.Any())
{
return;
}
var methods = builder
.FindMethodsByAttributes(methodInterceptionAttributes)
.Where(x => !x.Method.IsPropertyGetterSetter)
.GroupBy(x => new MethodKey(x.Method, x.AsyncMethod))
.Select(x => new MethodBuilderInfo <MethodBuilderInfoItem <BuilderTypeIMethodInterceptor, BuilderTypeISimpleMethodInterceptor> >(x.Key,
x.Select(y => new MethodBuilderInfoItem <BuilderTypeIMethodInterceptor, BuilderTypeISimpleMethodInterceptor>(y, BuilderTypes.IMethodInterceptor, BuilderTypes.ISimpleMethodInterceptor))))
.OrderBy(x => x.Key.Method.DeclaringType.Fullname)
.ToArray();
foreach (var method in methods)
{
if (method.Items == null || method.Items.Length == 0 || method.Key.Method.IsAbstract)
{
continue;
}
builder.Log(LogTypes.Info, $"Implementing method interceptors: {method.Key.Method.DeclaringType.Name.PadRight(40, ' ')} {method.Key.Method.Name}({string.Join(", ", method.Key.Method.Parameters.Select(x => x.Name))})");
var targetedMethod = method.Key.AsyncMethod ?? method.Key.Method;
var attributedMethod = method.Key.Method;
var hasSimpleMethodInterceptors = method.Items.Any(x => x.HasInterfaceB);
var hasFullMethodInterceptors = method.Items.Any(x => x.HasInterfaceA);
if (method.RequiresSyncRootField)
{
if (method.SyncRoot.IsStatic)
{
method.Key.Method.DeclaringType.CreateStaticConstructor().NewCoder()
.SetValue(method.SyncRoot, x => x.NewObj(builder.GetType(typeof(object)).Import().ParameterlessContructor))
.Insert(InsertionPosition.Beginning);
}
else
{
foreach (var ctors in method.Key.Method.DeclaringType.GetRelevantConstructors().Where(x => x.Name == ".ctor"))
{
ctors.NewCoder().SetValue(method.SyncRoot, x => x.NewObj(builder.GetType(typeof(object)).Import().ParameterlessContructor))
.Insert(InsertionPosition.Beginning);
}
}
}
var coder = targetedMethod
.NewCoder()
.Context(x =>
{
for (int i = 0; i < method.Items.Length; i++)
{
var item = method.Items[i];
var alwaysCreateNewInstance = item.InterceptorInfo.AlwaysCreateNewInstance;
var methodCoder = method.Key.Method.IsAsync ? method.Key.Method.NewCoder() : x;
Coder codeInterceptorInstance(Coder interceptorInstanceCoder)
{
interceptorInstanceCoder.SetValue(item.Interceptor, z => z.NewObj(item.Attribute));
if (item.HasSyncRootInterface)
{
interceptorInstanceCoder.Load <ICasting>(item.Interceptor).As(BuilderTypes.ISyncRoot).To <ICallMethod <CallCoder> >().Call(BuilderTypes.ISyncRoot.GetMethod_set_SyncRoot(), method.SyncRoot);
}
ModuleWeaver.ImplementAssignMethodAttribute(builder, method.Items[i].AssignMethodAttributeInfos, item.FieldOrVariable, item.Attribute.Attribute.Type, interceptorInstanceCoder);
return(interceptorInstanceCoder);
}
if (alwaysCreateNewInstance)
{
codeInterceptorInstance(methodCoder);
}
else
{
methodCoder.If(y => y.Load <IRelationalOperators>(item.Interceptor).IsNull(), y => codeInterceptorInstance(y));
}
if (method.Key.Method.IsAsync)
{
methodCoder.Insert(InsertionPosition.Beginning);
}
item.Attribute.Remove();
}
return(x);
});
if (hasSimpleMethodInterceptors)
{
var simpleMethodInterceptors = method.Items.Where(x => x.HasInterfaceB).ToArray();
coder.Context(x =>
{
if (method.Key.AsyncMethod != null)
{
x.If(num => num.Load(method.Key.Method.AsyncMethodHelper.StateVariable).Is(-1), then =>
ImplementOnEnterMethod(coder, x, then, method, attributedMethod, simpleMethodInterceptors, @interface => @interface.InterfaceB.GetMethod_OnEnter()));
}
else
{
ImplementOnEnterMethod(coder, x, method, attributedMethod, simpleMethodInterceptors, @interface => @interface.InterfaceB.GetMethod_OnEnter());
}
if (!hasFullMethodInterceptors)
{
return(x.OriginalBody());
}
return(x);
});
}
var fullMethodInterceptors = method.Items.Where(x => x.HasInterfaceA).ToArray();
if (hasFullMethodInterceptors)
{
if (method.Key.AsyncMethod != null)
{
coder.Context(x => x.If(num => num.Load(method.Key.Method.AsyncMethodHelper.StateVariable).Is(-1), then =>
ImplementOnEnterMethod(coder, x, then, method, attributedMethod, fullMethodInterceptors, @interface => @interface.InterfaceA.GetMethod_OnEnter()))
.OriginalBody());
}
else
{
coder.Try(x =>
{
ImplementOnEnterMethod(coder, x, method, attributedMethod, fullMethodInterceptors, @interface => @interface.InterfaceA.GetMethod_OnEnter());
return(x.OriginalBody());
})
.Catch(BuilderTypes.Exception.BuilderType, (eCoder, e) => eCoder.If(x =>
{
var or = x.Load <ICallMethod <BooleanExpressionCallCoder> >(fullMethodInterceptors[0].FieldOrVariable).Call(fullMethodInterceptors[0].InterfaceA.GetMethod_OnException(), e());
for (int i = 1; i < fullMethodInterceptors.Length; i++)
{
or.Or(y => y.Load <ICallMethod <CallCoder> >(fullMethodInterceptors[i].FieldOrVariable).Call(fullMethodInterceptors[i].InterfaceA.GetMethod_OnException(), e()));
}
return(or.Is(true));
}, then => eCoder.NewCoder().Rethrow()).DefaultValue().Return())
.Finally(x => ImplementOnExitMethod(x, method, fullMethodInterceptors))
.EndTry();
}
}
coder.Return().Replace();
if (method.Key.AsyncMethod != null && hasFullMethodInterceptors)
{
// Special case for async methods
var exceptionBlock = method.Key.Method.AsyncMethodHelper.GetAsyncStateMachineExceptionBlock();
targetedMethod
.NewCoder().Context(context =>
{
var exceptionVariable = method.Key.Method.AsyncMethodHelper.GetAsyncStateMachineExceptionVariable();
return(context.If(x =>
{
var or = x.Load(fullMethodInterceptors[0].FieldOrVariable as Field).Call(fullMethodInterceptors[0].InterfaceA.GetMethod_OnException(), exceptionVariable);
for (int i = 1; i < fullMethodInterceptors.Length; i++)
{
or.Or(y => y.Load(fullMethodInterceptors[i].FieldOrVariable as Field).Call(fullMethodInterceptors[i].InterfaceA.GetMethod_OnException(), exceptionVariable));
}
return or.Is(false);
}, x => x.Jump(exceptionBlock.Item1.End)));
})
.Insert(InsertionAction.After, exceptionBlock.Item1.Beginning);
targetedMethod
.NewCoder().Context(x => ImplementOnExitMethod(x, method, fullMethodInterceptors))
.Insert(InsertionAction.Before, exceptionBlock.Item1.End.Previous);
targetedMethod
.NewCoder().Context(context => ImplementOnExitMethod(context, method, fullMethodInterceptors))
.Insert(InsertionAction.After, exceptionBlock.Item1.End);
}
}
;
}
public List <Instruction> MakeCode()
{
if (!IsEnd)
{
var codes = new List <Instruction>
{
Start,
Processor.Create(OpCodes.Ldc_I4, Cmd),
Processor.Create(OpCodes.Bne_Un_S, Next),
Processor.Create(OpCodes.Ldarg_0)
};
int i = 0;
foreach (var parmeter in Method.Parameters)
{
codes.Add(Processor.Create(OpCodes.Ldarg_2));
codes.Add(Processor.Create(OpCodes.Ldc_I4, i));
codes.Add(Processor.Create(OpCodes.Ldelem_Ref));
ModuleWeaver.Convert(Processor, codes, ModuleWeaver.ModuleDefinition.ImportReference(typeof(object)), parmeter.ParameterType, true);
i++;
}
codes.Add(Processor.Create(OpCodes.Call, Method));
if (Method.ReturnType.Name != "Void")
{
codes.Add(Processor.Create(OpCodes.Ret));
}
else
{
codes.Add(End);
codes.Add(Processor.Create(OpCodes.Ret));
}
int size = 0;
foreach (var il in codes)
{
size += il.GetSize();
}
if (size > 120)
{
codes[2] = Processor.Create(OpCodes.Bne_Un, Next);
}
return(codes);
}
else
{
var codes = new List <Instruction>
{
Start,
Processor.Create(OpCodes.Ldc_I4, Cmd),
Processor.Create(OpCodes.Bne_Un_S, End),
Processor.Create(OpCodes.Ldarg_0)
};
int i = 0;
foreach (var parmeter in Method.Parameters)
{
codes.Add(Processor.Create(OpCodes.Ldarg_2));
codes.Add(Processor.Create(OpCodes.Ldc_I4, i));
codes.Add(Processor.Create(OpCodes.Ldelem_Ref));
ModuleWeaver.Convert(Processor, codes, ModuleWeaver.ModuleDefinition.ImportReference(typeof(object)), parmeter.ParameterType, true);
i++;
}
codes.Add(Processor.Create(OpCodes.Call, Method));
if (Method.ReturnType.Name != "Void")
{
codes.Add(Processor.Create(OpCodes.Ret));
}
int size = 0;
foreach (var il in codes)
{
size += il.GetSize();
}
if (size > 120)
{
codes[2] = Processor.Create(OpCodes.Bne_Un, End);
}
codes.Add(End);
codes.Add(Processor.Create(OpCodes.Ret));
return(codes);
}
}
void RuntimeWeaver()
{
var weaving = new ModuleWeaver();
weaving.ExecuteTestRun(System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), "AssemblyToProcess.dll"));
}
public static Assembly Weave(string code)
{
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code);
string[] assemblyPaths =
{
typeof(Exception).Assembly.Location,
typeof(DependencyObject).Assembly.Location,
typeof(DependencyPropertyAttribute).Assembly.Location,
typeof(FrameworkPropertyMetadataOptions).Assembly.Location,
typeof(Console).GetTypeInfo().Assembly.Location,
Path.Combine(Path.GetDirectoryName(typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly.Location), "System.Runtime.dll")
};
PortableExecutableReference[] references = assemblyPaths.Select(x => MetadataReference.CreateFromFile(x)).ToArray();
CSharpCompilation compilation = CSharpCompilation.Create(
Guid.NewGuid() + ".dll",
new[] { syntaxTree },
references,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
using (MemoryStream stream = new MemoryStream())
{
EmitResult result = compilation.Emit(stream);
if (!result.Success)
{
Console.Error.WriteLine("Compilation failed!");
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (Diagnostic diagnostic in failures)
{
Console.Error.WriteLine("\t{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
}
Assert.That(result.Success);
}
stream.Seek(0, SeekOrigin.Begin);
using (MemoryStream conversionStream = new MemoryStream())
using (ModuleDefinition module = ModuleDefinition.ReadModule(stream, new ReaderParameters {
InMemory = true
}))
{
ModuleWeaver weavingTask = new ModuleWeaver
{
ModuleDefinition = module
};
weavingTask.Execute();
module.Write(conversionStream);
conversionStream.Seek(0, SeekOrigin.Begin);
using (FileStream fileStream = File.Create($"{Guid.NewGuid()}.dll"))
{
conversionStream.CopyToAsync(fileStream);
conversionStream.Seek(0, SeekOrigin.Begin);
}
return(Assembly.Load(conversionStream.ToArray()));
}
}
}
public FSharpTest()
{
var weavingTask = new ModuleWeaver();
testResult = weavingTask.ExecuteTestRun("AssemblyFSharp.dll", runPeVerify: false);
}
public AssemblyWithBaseInDifferentModuleTests()
{
var weavingTask = new ModuleWeaver();
testResult = weavingTask.ExecuteTestRun("AssemblyWithBaseInDifferentModule.dll", ignoreCodes: new[] { "0x80131869" });
}
static AbleToWeaveTest()
{
var weavingTask = new ModuleWeaver();
TestResult = weavingTask.ExecuteTestRun("AssemblyToProcess.dll", false);
}
public TypeFilterTests()
{
var weavingTask = new ModuleWeaver();
testResult = weavingTask.ExecuteTestRun("AssemblyWithTypeFilter.dll");
}
private static TypeReference Resolve(this ModuleWeaver weaver, string typename)
=> weaver.ModuleDefinition.ImportReference(weaver.FindTypeDefinition(typename) ?? throw new WeavingException($"Couldnt find {typename}!"));
static Weaver_Test()
{
var weavingTask = new ModuleWeaver();
testResult = weavingTask.ExecuteTestRun("AssemblyToProcess.dll");
}
public AssemblyInfo GetAssembly(string testCaseName, string configString)
{
if (!_assemblies.ContainsKey(configString))
{
var type = typeof(DummyDependencyInjectionClass);
var assemblyInfo = new AssemblyInfo
{
BeforeAssemblyPath = type.GetAssemblyEx().Location
};
var rootDirectory = Directory.GetParent(assemblyInfo.BeforeAssemblyPath).FullName;
var testCaseDirectory = Path.Combine(rootDirectory, testCaseName);
Directory.CreateDirectory(testCaseDirectory);
assemblyInfo.AfterAssemblyPath = Path.Combine(testCaseDirectory, Path.GetFileName(assemblyInfo.BeforeAssemblyPath));
var oldPdb = Path.ChangeExtension(assemblyInfo.BeforeAssemblyPath, "pdb");
var newPdb = Path.ChangeExtension(assemblyInfo.AfterAssemblyPath, "pdb");
if (File.Exists(oldPdb))
{
File.Copy(oldPdb, newPdb, true);
}
Debug.WriteLine("Weaving assembly on-demand from '{0}' to '{1}'", assemblyInfo.BeforeAssemblyPath, assemblyInfo.AfterAssemblyPath);
var assemblyResolver = new TestAssemblyResolver();
//assemblyResolver.AddSearchDirectory(testCaseDirectory);
//assemblyResolver.AddSearchDirectory(rootDirectory);
var metadataResolver = new MetadataResolver(assemblyResolver);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver,
MetadataResolver = metadataResolver,
ReadSymbols = File.Exists(oldPdb),
};
using (var moduleDefinition = ModuleDefinition.ReadModule(assemblyInfo.BeforeAssemblyPath, readerParameters))
{
// Important note: the test project can be on a completely different location (especially on a build agent)
var projectName = Path.GetFileName(assemblyInfo.BeforeAssemblyPath).Replace(".dll", string.Empty);
// Check 1: fixed location from test
var relativeCsProjectFilePath = Path.Combine(Directory.GetParent(assemblyInfo.BeforeAssemblyPath).FullName, "..", "..", "..", "..", "src", projectName, $"{projectName}.csproj");
var csProjectFilePath = Path.GetFullPath(relativeCsProjectFilePath);
if (!File.Exists(csProjectFilePath))
{
// Check 2: Check 2 directories up, then search for the project file (happens on a build agent)
var searchDirectory = Path.Combine(Directory.GetParent(assemblyInfo.BeforeAssemblyPath).FullName, "..", "..", "..", "Source");
var searchFileName = $"{projectName}.csproj";
csProjectFilePath = Directory.GetFiles(searchDirectory, searchFileName, SearchOption.AllDirectories).FirstOrDefault();
}
if (!File.Exists(csProjectFilePath))
{
throw new System.Exception($"Project file '{csProjectFilePath}' does not exist, make sure to check the paths since this is required for the unit tests");
}
var weavingTask = new ModuleWeaver
{
Config = XElement.Parse(configString),
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
ProjectFilePath = csProjectFilePath,
LogError = (x) =>
{
assemblyInfo.Errors.Add(x);
},
};
weavingTask.Execute();
moduleDefinition.Write(assemblyInfo.AfterAssemblyPath);
}
// if (Debugger.IsAttached)
// {
//#if DEBUG
// var output = "debug";
//#else
// var output = "release";
//#endif
// var targetFile = $@"C:\Source\Catel.Fody\output\{output}\Catel.Fody.Tests\Catel.Fody.TestAssembly2.dll";
// var targetDirectory = Path.GetDirectoryName(targetFile);
// Directory.CreateDirectory(targetDirectory);
// File.Copy(AfterAssemblyPath, targetFile, true);
// }
assemblyInfo.Assembly = Assembly.LoadFile(assemblyInfo.AfterAssemblyPath);
_assemblies[configString] = assemblyInfo;
}
return(_assemblies[configString]);
}
private static void AddPropertySetterInterception(
Builder builder,
BuilderTypePropertyInterceptionInfo propertyInterceptionInfo,
PropertyBuilderInfo member,
Field propertyField,
Method actionObjectCtor,
Method propertySetter,
Dictionary <string, Field> interceptorFields)
{
var syncRoot = BuilderTypes.ISyncRoot;
var legalSetterInterceptors = member.InterceptorInfos.Where(x => x.InterfaceSetter != null).ToArray();
member.Property.Setter
.NewCoder()
.Context(context =>
{
if (member.HasInitializer)
{
return(context);
}
for (int i = 0; i < legalSetterInterceptors.Length; i++)
{
var item = legalSetterInterceptors[i];
var alwaysCreateNewInstance = item.InterceptorInfo.AlwaysCreateNewInstance && item.InterfaceInitializer == null;
var fieldOrVariable = interceptorFields[item.Attribute.Identification] as CecilatorBase ??
context.AssociatedMethod.GetOrCreateVariable(item.Attribute.Attribute.Type, item.Attribute.Identification);
Coder implementInterceptorInitialization(Coder coder)
{
coder.SetValue(fieldOrVariable, x => x.NewObj(item.Attribute));
if (item.HasSyncRootInterface)
{
coder.Load <ICasting>(fieldOrVariable).As(syncRoot.BuilderType.Import()).To <ICallMethod <CallCoder> >().Call(syncRoot.GetMethod_set_SyncRoot(), member.SyncRoot);
}
ModuleWeaver.ImplementAssignMethodAttribute(builder, legalSetterInterceptors[i].AssignMethodAttributeInfos, fieldOrVariable, item.Attribute.Attribute.Type, coder);
return(coder);
}
if (alwaysCreateNewInstance)
{
implementInterceptorInitialization(context);
}
else
{
context.If(x => x.Load <IRelationalOperators>(fieldOrVariable).IsNull(), then => implementInterceptorInitialization(then));
}
item.Attribute.Remove();
}
return(context.If(x => x.Load(propertyField).IsNull(), then =>
then.SetValue(propertyField, x =>
x.NewObj(propertyInterceptionInfo.GetMethod_ctor(),
member.Property.Getter,
member.Property.Setter,
member.Property.Name,
member.Property.ReturnType,
CodeBlocks.This,
member.Property.ReturnType.IsArray || member.Property.ReturnType.Implements(typeof(IEnumerable)) ? member.Property.ReturnType.ChildType : null,
propertySetter == null ? null : x.NewCoder().NewObj(actionObjectCtor, propertySetter.ThisOrNull(), propertySetter)))));
})
.Try(@try =>
{
if (member.Property.BackingField == null)
{
// If we don't have a backing field, we will try getting the value from the
// getter itself... But in this case we have to watch out that we don't accidentally code a
// StackOverFlow
var oldvalue = member.Property.Getter == null ? null : member.Property.Setter.GetOrCreateVariable(member.Property.ReturnType);
if (oldvalue != null)
{
var getter = member.Property.Getter.Copy();
@try.SetValue(oldvalue, y => y.Call(getter));
}
for (int i = 0; i < legalSetterInterceptors.Length; i++)
{
var item = legalSetterInterceptors[i];
var alwaysCreateNewInstance = item.InterceptorInfo.AlwaysCreateNewInstance && item.InterfaceInitializer == null;
var fieldOrVariable = interceptorFields[item.Attribute.Identification] as CecilatorBase ?? @try.AssociatedMethod.GetVariable(item.Attribute.Identification);
@try.If(x =>
x.Load <ICasting>(fieldOrVariable)
.As(legalSetterInterceptors[i].InterfaceSetter)
.To <ICallMethod <BooleanExpressionCallCoder> >()
.Call(item.InterfaceSetter.GetMethod_OnSet(), propertyField, oldvalue, CodeBlocks.GetParameter(0))
.To <IRelationalOperators>()
.Is(false), then => then.OriginalBody(true));
}
}
else
{
@try.If(x => x.And(legalSetterInterceptors,
(coder, item, i) =>
{
var fieldOrVariable = interceptorFields[item.Attribute.Identification] as CecilatorBase ?? @try.AssociatedMethod.GetVariable(item.Attribute.Identification);
return(coder.Load <ICasting>(fieldOrVariable)
.As(legalSetterInterceptors[i].InterfaceSetter)
.To <ICallMethod <BooleanExpressionCallCoder> >()
.Call(item.InterfaceSetter.GetMethod_OnSet(), propertyField, member.Property.BackingField, CodeBlocks.GetParameter(0)));
}).Is(false), then => then.OriginalBody());
}
return(@try);
})
.Catch(typeof(Exception), (ex, e) =>
{
return(ex.If(x => x.Or(legalSetterInterceptors,
(coder, y, i) =>
{
var fieldOrVariable = interceptorFields[y.Attribute.Identification] as CecilatorBase ?? ex.AssociatedMethod.GetVariable(y.Attribute.Identification);
return coder.Load <ICasting>(fieldOrVariable)
.As(legalSetterInterceptors[i].InterfaceSetter)
.To <ICallMethod <BooleanExpressionCallCoder> >()
.Call(legalSetterInterceptors[i].InterfaceSetter.GetMethod_OnException(), e());
}).Is(true), then => ex.NewCoder().Rethrow())
.DefaultValue()
.Return());
})
.Finally(x =>
{
for (int i = 0; i < legalSetterInterceptors.Length; i++)
{
var item = legalSetterInterceptors[i];
var fieldOrVariable = interceptorFields[item.Attribute.Identification] as CecilatorBase ?? x.AssociatedMethod.GetVariable(item.Attribute.Identification);
x.Load <ICasting>(fieldOrVariable)
.As(legalSetterInterceptors[i].InterfaceSetter)
.To <ICallMethod <CallCoder> >()
.Call(legalSetterInterceptors[i].InterfaceSetter.GetMethod_OnExit());
}
return(x);
})
.EndTry()
.Return()
.Replace();
}
public EqualityCheckWeaver(PropertyData propertyData, TypeDefinition typeDefinition, ModuleWeaver typeEqualityFinder)
{
this.propertyData = propertyData;
this.typeDefinition = typeDefinition;
this.typeEqualityFinder = typeEqualityFinder;
}
public void Run()
{
var memberMappings = ModuleWeaver.GetMappings(DefinitionFinder.FindType <Model>()).ToList();
Assert.IsNull(memberMappings.Single().FieldDefinition);
}
public void CanDetectStackOverflow()
{
var weavingTask = new ModuleWeaver();
Assert.Throws <WeavingException>(() => { weavingTask.ExecuteTestRun("AssemblyWithStackOverflow.dll"); });
}