public void Should_verify_current_assembly()
{
var verify = PeVerifier.Verify(assemblyPath, GetIgnoreCodes(), out var output);
Assert.True(verify);
Assert.NotNull(output);
}
protected void AssertRunPeVerify(ModuleWeaver weaver)
{
Action action = () =>
{
var runIlSpy = false;
try
{
PeVerifier.Verify(Weave.DllPath);
}
catch (Exception)
{
runIlSpy = true;
throw;
}
finally
{
if (runIlSpy || IlSpy.AlwaysRunIlSpy)
{
var methodName = weaver?.MethodFilters.Single();
IlSpy.ShowMethod(methodName, Weave.DllPath);
IlSpy.ShowMethod(methodName, Source.DllPath);
Thread.Sleep(TimeSpan.FromSeconds(2)); // wait until ILSpy is started because weaved dll will be deleted when unittests exits -> TryCleanupWeavedFiles()
}
}
};
action.Should().NotThrow();
}
public void Should_verify_current_assembly()
{
var verify = PeVerifier.Verify(GetAssemblyPath(), Enumerable.Empty<string>(), out var output);
Assert.True(verify);
Assert.NotNull(output);
Assert.NotEmpty(output);
}
bool InnerVerify()
{
if (!File.Exists(TargetPath))
{
Logger.LogInfo($" Cannot verify assembly, file '{TargetPath}' does not exist");
return(true);
}
if (!ReadShouldVerifyAssembly(out var ignoreCodes))
{
Logger.LogInfo(" Skipped Verifying assembly since it is disabled in configuration");
return(true);
}
if (!PeVerifier.FoundPeVerify)
{
Logger.LogInfo(" Skipped Verifying assembly since could not find peverify.exe.");
return(true);
}
Logger.LogInfo(" Verifying assembly");
ignoreCodes.Add("0x80070002");
if (PeVerifier.Verify(TargetPath, ignoreCodes, out var output))
{
return(true);
}
Logger.LogError($"PEVerify of the assembly failed.\n{output}");
return(false);
}
private void RunPeVerify()
{
Action action = () =>
{
var runIlSpy = false;
try
{
PeVerifier.Verify(WeavedAssemblyPath);
}
catch (Exception)
{
runIlSpy = true;
throw;
}
finally
{
if (runIlSpy || IlSpy.AlwaysRunIlSpy)
{
RunIlSpy();
}
}
};
action.Should().NotThrow();
}
public void Setup()
{
var weavingTask = new ModuleWeaver
{
ClassNames = new List <string> {
BaseClassName
},
AllowNonPublic = ProcessNonPublicToo
};
var asm = Assembly.GetAssembly(typeof(InjectionTests));
var subjectPath = Path.Combine(Path.GetDirectoryName(asm.Location), TestLibraryName);
// run pe verify separately to prevent 'Unable to resolve token.(Error: 0x80131869)' errors with weavingTask
var valid = PeVerifier.Verify(subjectPath,
subjectPath,
PEVerifyIgnoreCodes,
out var beforeOutput,
out var afterOutput);
Assert.IsTrue(valid);
testResult = weavingTask.ExecuteTestRun(subjectPath, runPeVerify: false);
processedAssembly = testResult.Assembly;
TestContext.Out.WriteLine($"Run tests for {BaseClassName}, {nameof(ProcessNonPublicToo)}={ProcessNonPublicToo}");
}
private void RunPeVerify(IEnumerable <string> ignoreErrorCodes)
{
Action action = () =>
{
var runIlSpy = false;
try
{
PeVerifier.Verify(WeavedAssemblyPath, ignoreErrorCodes);
}
catch (Exception)
{
runIlSpy = true;
throw;
}
finally
{
if (runIlSpy || IlSpy.AlwaysRunIlSpy)
{
RunIlSpy();
}
}
};
action.Should().NotThrow();
}
public void Same_assembly_should_not_throw()
{
var assemblyPath = GetAssemblyPath().ToLowerInvariant();
var newAssemblyPath = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssemblyPath, true);
PeVerifier.ThrowIfDifferent(assemblyPath, newAssemblyPath);
File.Delete(newAssemblyPath);
}
public void Same_assembly_should_not_throw()
{
Directory.CreateDirectory("temp");
var newAssemblyPath = Path.GetFullPath("temp/temp.dll");
File.Copy(assemblyPath, newAssemblyPath, true);
PeVerifier.ThrowIfDifferent(assemblyPath, newAssemblyPath,
ignoreCodes: GetIgnoreCodes());
File.Delete(newAssemblyPath);
}
public void TrimLineNumbers()
{
var text = PeVerifier.TrimLineNumbers(@"
[IL]: Error: [C:\Code\net452\AssemblyToProcess.dll : UnsafeClass::MethodWithAmp][offset 0x00000002][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
[IL]: Error: [C:\Code\net452\AssemblyToProcess.dll : UnsafeClass::get_NullProperty][offset 0x00000006][found unmanaged pointer][expected unmanaged pointer] Unexpected type on the stack.
[IL]: Error: [C:\Code\net452\AssemblyToProcess.dll : UnsafeClass::set_NullProperty][offset 0x00000001] Unmanaged pointers are not a verifiable type.
3 Error(s) Verifying C:\Code\Fody\net452\AssemblyToProcess.dll");
Approvals.Verify(text);
}
public void Invalid_assembly_should_throw()
{
var assemblyPath = GetAssemblyPath().ToLowerInvariant();
var newAssemblyPath = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssemblyPath, true);
using (var moduleDefinition = ModuleDefinition.ReadModule(assemblyPath))
{
moduleDefinition.AssemblyReferences.Clear();
moduleDefinition.Write(newAssemblyPath);
}
Assert.Throws<Exception>(() => PeVerifier.ThrowIfDifferent(assemblyPath, newAssemblyPath));
File.Delete(newAssemblyPath);
}
public void Invalid_assembly_should_throw()
{
Directory.CreateDirectory("temp");
var newAssemblyPath = Path.GetFullPath("temp/temp.dll");
File.Copy(assemblyPath, newAssemblyPath, true);
using (var moduleDefinition = ModuleDefinition.ReadModule(assemblyPath))
{
moduleDefinition.AssemblyReferences.Clear();
moduleDefinition.Write(newAssemblyPath);
}
Assert.Throws <Exception>(() => PeVerifier.ThrowIfDifferent(assemblyPath, newAssemblyPath));
File.Delete(newAssemblyPath);
}
bool InnerVerify()
{
if (!File.Exists(TargetPath))
{
Logger.LogInfo($" Cannot verify assembly, file '{TargetPath}' does not exist");
return(true);
}
if (!ReadShouldVerifyAssembly(out var ignoreCodes))
{
Logger.LogInfo(" Skipped Verifying assembly since it is disabled in configuration");
return(true);
}
if (!PeVerifier.FoundPeVerify)
{
Logger.LogInfo(" Skipped Verifying assembly since could not find peverify.exe.");
return(true);
}
var stopwatch = Stopwatch.StartNew();
try
{
Logger.LogInfo(" Verifying assembly");
ignoreCodes.Add("0x80070002");
if (PeVerifier.Verify(TargetPath, ignoreCodes, out var output))
{
return(true);
}
Logger.LogError($"PEVerify of the assembly failed.\n{output}");
return(false);
}
finally
{
Logger.LogInfo($" Finished verification in {stopwatch.ElapsedMilliseconds}ms.");
}
}
public void PeVerify()
{
var weaver = AssemblyWeaver.Instance;
PeVerifier.ThrowIfDifferent(weaver.BeforeAssemblyPath, weaver.AfterAssemblyPath);
}
public static TestResult ExecuteVandelayTestRun(
this BaseModuleWeaver weaver,
string assemblyPath,
bool runPeVerify = true,
Action <ModuleDefinition> afterExecuteCallback = null,
Action <ModuleDefinition> beforeExecuteCallback = null,
string assemblyName = null,
IEnumerable <string> ignoreCodes = null,
bool purgeTempDir = true,
StrongNameKeyPair strongNameKeyPair = null)
{
assemblyPath = Path.Combine(CodeBaseLocation.CurrentDirectory, assemblyPath);
var fodyTempDir = Path.Combine(Path.GetDirectoryName(assemblyPath), "fodytemp");
Directory.CreateDirectory(fodyTempDir);
if (purgeTempDir)
{
var info = new DirectoryInfo(fodyTempDir);
foreach (var file in info.GetFiles())
{
file.Delete();
}
foreach (var directory in info.GetDirectories())
{
directory.Delete(true);
}
}
string targetFileName;
if (assemblyName == null)
{
assemblyName = Path.GetFileNameWithoutExtension(assemblyPath);
targetFileName = Path.GetFileName(assemblyPath);
}
else
{
targetFileName = assemblyName + ".dll";
}
var targetAssemblyPath = Path.Combine(fodyTempDir, targetFileName);
using (var assemblyResolver = new TestAssemblyResolver())
{
var typeCache = CacheTypes(weaver, assemblyResolver.Resolve);
var testStatus = new TestResult();
var addMessageInfo = typeof(TestResult).GetMethod("AddMessage",
BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Assert(addMessageInfo != null, $"{nameof(addMessageInfo)} != null");
var addMessage = addMessageInfo
.CreateDelegate <Action <string, MessageImportance> >(testStatus);
var addWarningInfo = typeof(TestResult).GetMethod("AddWarning",
BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Assert(addWarningInfo != null, $"{nameof(addWarningInfo)} != null");
var addWarning = addWarningInfo
.CreateDelegate <Action <string, SequencePoint> >(testStatus);
var addErrorInfo = typeof(TestResult).GetMethod("AddError",
BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Assert(addErrorInfo != null, $"{nameof(addErrorInfo)} != null");
var addError = addErrorInfo
.CreateDelegate <Action <string, SequencePoint> >(testStatus);
weaver.LogDebug = text => addMessage(text, MessageImportanceDefaults.Debug);
weaver.LogInfo = text => addMessage(text, MessageImportanceDefaults.Info);
weaver.LogMessage = (text, messageImportance) => addMessage(text, messageImportance);
weaver.LogWarning = text => addWarning(text, null);
weaver.LogWarningPoint = (text, sequencePoint) => addWarning(text, sequencePoint);
weaver.LogError = text => addError(text, null);
weaver.LogErrorPoint = (text, sequencePoint) => addError(text, sequencePoint);
weaver.AssemblyFilePath = assemblyPath;
weaver.FindType = typeCache.FindType;
weaver.TryFindType = typeCache.TryFindType;
weaver.ResolveAssembly = assemblyResolver.Resolve;
var readerProviderType = typeof(BaseModuleWeaver).Assembly
.GetType("SymbolReaderProvider", true);
var readerProvider = (ISymbolReaderProvider)Activator.CreateInstance(readerProviderType);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver,
SymbolReaderProvider = readerProvider,
ReadWrite = false,
ReadSymbols = true,
};
using (var module = ModuleDefinition.ReadModule(assemblyPath, readerParameters))
{
module.Assembly.Name.Name = assemblyName;
weaver.ModuleDefinition = module;
weaver.TypeSystem = new TypeSystem(typeCache.FindType, module);
beforeExecuteCallback?.Invoke(module);
weaver.Execute();
var referenceCleanerType = typeof(BaseModuleWeaver).Assembly
.GetType("ReferenceCleaner", true);
var cleanReferencesInfo = referenceCleanerType.GetMethod("CleanReferences");
Debug.Assert(cleanReferencesInfo != null, nameof(cleanReferencesInfo) + " != null");
var cleaner = cleanReferencesInfo
.CreateDelegate <Action <ModuleDefinition, BaseModuleWeaver, Action <string> > >();
cleaner(module, weaver, weaver.LogDebug);
afterExecuteCallback?.Invoke(module);
var writerParameters = new WriterParameters
{
StrongNameKeyPair = strongNameKeyPair,
WriteSymbols = true
};
module.Write(targetAssemblyPath, writerParameters);
}
if (runPeVerify && IsWindows())
{
var ignoreList = ignoreCodes == null ? new List <string>() : ignoreCodes.ToList();
PeVerifier.ThrowIfDifferent(assemblyPath, targetAssemblyPath, ignoreList,
Path.GetDirectoryName(assemblyPath));
}
#if NETSTANDARD
AppDomain.CurrentDomain.AssemblyResolve += (_, args) =>
{
var tempAssemblyPath = Path.Combine(fodyTempDir, new AssemblyName(args.Name).Name + ".dll");
return(!File.Exists(tempAssemblyPath) ? null : Assembly.LoadFrom(tempAssemblyPath));
};
#endif
typeof(TestResult).GetMethod("set_Assembly",
BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(testStatus, new object[]
{
Assembly.Load(AssemblyName.GetAssemblyName(targetAssemblyPath))
});
typeof(TestResult).GetMethod("set_AssemblyPath",
BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(testStatus, new object[]
{
targetAssemblyPath
});
return(testStatus);
}
}
private void RunPeVerify()
{
Action action = () => PeVerifier.Verify(WeavedAssemblyPath);
action.ShouldNotThrow();
}
private void RunPeVerify()
{
var result = PeVerifier.Verify(WeavedAssemblyPath);
result.Should().Be(0, "PeVerifier failed!");
}
