static void ParseErrors(PeVerifyResult result, string stdOut)
{
result.Errors = new List <string>();
int startIndex = 0;
while (startIndex < stdOut.Length)
{
startIndex = stdOut.IndexOf("[IL]:", startIndex);
if (startIndex == -1)
{
break;
}
int endIndex = stdOut.IndexOf("[IL]:", startIndex + 1);
if (endIndex == -1)
{
// Look for the last line...
endIndex = stdOut.IndexOf("\r\n", startIndex + 1);
}
result.Errors.Add(result.NormalizeErrorString(stdOut.Substring(startIndex, endIndex - startIndex)));
startIndex = endIndex;
}
}
void RoundTripCodeCopier(string assemblyName, string pdbName, bool allowCheckerFail)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
if (pdbName != null)
{
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, pdbReader);
CodeDeepCopier copier = new CodeDeepCopier(host);
codeAssembly = copier.Copy(codeAssembly);
Checker checker = new Checker(this.host);
checker.Traverse(codeAssembly);
Debug.Assert(checker.Errors.Count == 0);
AssertWriteToPeFile(expectedResult, codeAssembly, pdbReader);
}
}
}
else
{
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, null);
CodeDeepCopier copier = new CodeDeepCopier(host);
codeAssembly = copier.Copy(codeAssembly);
Checker checker = new Checker(this.host);
checker.Traverse(codeAssembly);
Debug.Assert(allowCheckerFail || checker.Errors.Count == 0);
AssertWriteToPeFile(expectedResult, codeAssembly, null);
}
}
void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly, string pdbPath)
{
var validator = new MetadataValidator(this.host);
List <Microsoft.Cci.ErrorEventArgs> errorEvents = new List <Microsoft.Cci.ErrorEventArgs>();
this.host.Errors += (object sender, Microsoft.Cci.ErrorEventArgs e) => errorEvents.Add(e);
validator.Validate(assembly);
Debug.Assert(errorEvents.Count == 0);
using (var rewrittenFile = File.Create(assembly.Location)) {
if (pdbPath != null)
{
using (var f = File.OpenRead(pdbPath)) {
using (var pdbReader = new PdbReader(f, host)) {
using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), pdbReader)) {
PeWriter.WritePeToStream(assembly, host, rewrittenFile, pdbReader, pdbReader, pdbWriter);
}
}
}
}
else
{
using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), null)) {
PeWriter.WritePeToStream(assembly, host, rewrittenFile, null, null, pdbWriter);
}
}
}
Assert.True(File.Exists(assembly.Location));
PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location, true));
}
void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly, PdbReader pdbReader)
{
using (var rewrittenFile = File.Create(assembly.Location)) {
using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), pdbReader)) {
PeWriter.WritePeToStream(assembly, host, rewrittenFile, pdbReader, pdbReader, pdbWriter);
}
}
Assert.True(File.Exists(assembly.Location));
PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location, true));
}
public static PeVerifyResult VerifyAssembly(string assemblyName, bool verificationMayFail)
{
PeVerifyResult result = RunPeVerifyOnAssembly(assemblyName);
if (result.ExitCode != 0 && !verificationMayFail)
{
throw new Exception("PeVerify Failed with " + result.Errors.Count + " different errors.");
}
return(result);
}
void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly)
{
using (FileStream rewrittenFile = File.Create(assembly.Location)) {
using (this.pdbReader) {
PeWriter.WritePeToStream(assembly, this.host, rewrittenFile, this.pdbReader, this.pdbReader, this.pdbWriter);
}
}
Assert.True(File.Exists(assembly.Location));
PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location));
}
void RoundTripWithCodeMutator(PeVerifyResult expectedResult, string assemblyName, string pdbName)
{
IAssembly assembly = LoadAssembly(assemblyName);
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, pdbReader);
RoundTripWithMutator(expectedResult, codeAssembly, CreateCodeMutator(codeAssembly, pdbName));
}
}
}
private static PeVerifyResult RunPeVerifyOnAssembly(string assemblyName) {
PeVerifyResult result = new PeVerifyResult();
result.AssemblyName = assemblyName;
string stdOut, stdErr;
result.ExitCode = StartAndWaitForResult(PeVerifyPath, assemblyName + " /UNIQUE /IL /NOLOGO", out stdOut, out stdErr);
ParseErrors(result, stdOut);
return result;
}
void RoundTripMutableCopyMarkedNodes(string assemblyName, string pdbName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var adder = new CopyMarkedNodes(host);
var codeAssembly = adder.Rewrite(assembly);
AssertWriteToPeFile(expectedResult, codeAssembly, pdbReader);
}
}
}
public static PeVerifyResult RunPeVerifyOnAssembly(string assemblyName)
{
PeVerifyResult result = new PeVerifyResult();
result.AssemblyName = assemblyName;
string stdOut, stdErr;
result.ExitCode = StartAndWaitForResult(PeVerifyPath, assemblyName + " /UNIQUE /IL /NOLOGO", out stdOut, out stdErr);
ParseErrors(result, stdOut);
return(result);
}
void RoundTripMutableCopyAndAddGenericParameter2(string assemblyName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
var copier1 = new MetadataDeepCopier(host);
var codeAssembly = copier1.Copy(assembly);
for (int i = 0; i < 30; i++)
{
AddGenericParameters adder = new AddGenericParameters(host, codeAssembly.AllTypes, i);
codeAssembly = (Assembly)adder.Rewrite(codeAssembly);
}
AssertWriteToPeFile(expectedResult, codeAssembly, null);
}
void RoundTripNoCopyTestDecompilation(string assemblyName, string pdbName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, pdbReader);
Checker checker = new Checker(this.host);
checker.Traverse(codeAssembly);
Debug.Assert(checker.Errors.Count == 0);
AssertWriteToPeFile(expectedResult, codeAssembly, pdbReader);
}
}
}
void RoundTripMutableCopyAndAddGenericParameter(string assemblyName, string pdbName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, pdbReader);
codeAssembly = new CodeDeepCopier(host).Copy(codeAssembly);
AddGenericParameters adder = new AddGenericParameters(host, codeAssembly.AllTypes, 0);
codeAssembly = (Assembly)adder.Rewrite(codeAssembly);
Checker checker = new Checker(this.host);
checker.Traverse(codeAssembly);
Debug.Assert(checker.Errors.Count == 0);
AssertWriteToPeFile(expectedResult, codeAssembly, pdbReader);
}
}
}
public static void Assert(PeVerifyResult expectedResult, PeVerifyResult actualResult)
{
foreach (var e in expectedResult.Errors)
{
actualResult.Errors.Remove(e);
}
// TODO: Ideally this will be with peverify v4.0, and this won't be needed.
if (actualResult.Errors.Count > expectedResult.Errors.Count)
{
Console.WriteLine("Expected:");
expectedResult.Errors.ForEach(Console.WriteLine);
Console.WriteLine();
Console.WriteLine("Actual:");
actualResult.Errors.ForEach(Console.WriteLine);
Console.WriteLine("PeVerify: {0}", expectedResult.AssemblyName);
throw new Exception("PeVerify Failed with " + actualResult.Errors.Count + " different errors.");
}
}
void RoundTripCopyAndExecute(string assemblyName, string pdbName, bool verificationMayFail)
{
PeVerifyResult expectedResult = !verificationMayFail
? PeVerify.VerifyAssembly(assemblyName)
: PeVerify.RunPeVerifyOnAssembly(assemblyName);
string expectedOutput = Execute(assemblyName);
IAssembly assembly = LoadAssembly(assemblyName);
using (var f = File.OpenRead(pdbName)) {
using (var pdbReader = new PdbReader(f, host)) {
var codeAssembly = Decompiler.GetCodeModelFromMetadataModel(this.host, assembly, pdbReader);
var copier = new CodeDeepCopier(host);
codeAssembly = copier.Copy(codeAssembly);
Checker checker = new Checker(this.host);
checker.Traverse(codeAssembly);
Debug.Assert(checker.Errors.Count == 0);
AssertWriteToPeFile(expectedResult, codeAssembly, pdbReader);
AssertExecute(expectedOutput, assemblyName);
}
}
}
void RoundTripWithMutator(PeVerifyResult expectedResult, IAssembly assembly, MetadataRewriter mutator, string pdbPath) {
var result = this.VisitAndMutate(mutator, assembly);
AssertWriteToPeFile(expectedResult, result, pdbPath);
}
public static void Assert(PeVerifyResult expectedResult, PeVerifyResult actualResult) {
foreach (var e in expectedResult.Errors) {
actualResult.Errors.Remove(e);
}
// TODO: Ideally this will be with peverify v4.0, and this won't be needed.
if (actualResult.Errors.Count > expectedResult.Errors.Count) {
Console.WriteLine("Expected:");
expectedResult.Errors.ForEach(Console.WriteLine);
Console.WriteLine();
Console.WriteLine("Actual:");
actualResult.Errors.ForEach(Console.WriteLine);
Console.WriteLine("PeVerify: {0}", expectedResult.AssemblyName);
throw new Exception("PeVerify Failed with " + actualResult.Errors.Count + " different errors.");
}
}
static void ParseErrors(PeVerifyResult result, string stdOut) {
result.Errors = new List<string>();
if (result.ExitCode == 0) return;
int startIndex = 0;
while (startIndex < stdOut.Length) {
startIndex = stdOut.IndexOf("[IL]:", startIndex);
if (startIndex == -1) break;
int endIndex = stdOut.IndexOf("[IL]:", startIndex + 1);
if (endIndex == -1) {
// Look for the last line...
endIndex = stdOut.IndexOf("\r\n", startIndex + 1);
}
result.Errors.Add(result.NormalizeErrorString(stdOut.Substring(startIndex, endIndex - startIndex)));
startIndex = endIndex;
}
}
void RoundTripWithMutator(PeVerifyResult expectedResult, IAssembly assembly, MetadataRewriter mutator, string pdbPath)
{
var result = this.VisitAndMutate(mutator, assembly);
AssertWriteToPeFile(expectedResult, result, pdbPath);
}
void RoundTripWithILMutator(string assemblyName, string pdbPath, bool verificationMayFail)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName, verificationMayFail);
RoundTripWithMutator(expectedResult, LoadAssembly(assemblyName), new MetadataRewriter(host), pdbPath);
}
void RoundTripWithMutator(PeVerifyResult expectedResult, IAssembly assembly, MetadataRewriter mutator)
{
this.VisitAndMutate(mutator, ref assembly);
AssertWriteToPeFile(expectedResult, assembly);
}
void RoundTripWithILMutator(string assemblyName, string pdbName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
RoundTripWithMutator(expectedResult, LoadAssembly(assemblyName), new MetadataRewriter(host));
}
void RoundTripWithCodeMutator(string assemblyName, string pdbName)
{
PeVerifyResult expectedResult = PeVerify.VerifyAssembly(assemblyName);
RoundTripWithCodeMutator(expectedResult, assemblyName, pdbName);
}
void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly, string pdbPath) {
var validator = new MetadataValidator(this.host);
List<Microsoft.Cci.ErrorEventArgs> errorEvents = new List<Microsoft.Cci.ErrorEventArgs>();
this.host.Errors += (object sender, Microsoft.Cci.ErrorEventArgs e) => errorEvents.Add(e);
validator.Validate(assembly);
Debug.Assert(errorEvents.Count == 0);
using (var rewrittenFile = File.Create(assembly.Location)) {
if (pdbPath != null) {
using (var f = File.OpenRead(pdbPath)) {
using (var pdbReader = new PdbReader(f, host)) {
using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), pdbReader)) {
PeWriter.WritePeToStream(assembly, host, rewrittenFile, pdbReader, pdbReader, pdbWriter);
}
}
}
} else {
using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), null)) {
PeWriter.WritePeToStream(assembly, host, rewrittenFile, null, null, pdbWriter);
}
}
}
Assert.True(File.Exists(assembly.Location));
PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location, true));
}
