protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("AssemblyWithOneType"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("ReflectArgument",
MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Public,
typeof(int), new Type[] { typeof(int) })))
{
method.Emit(OpCodes.Ldarg_0);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatThrowsException"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("ThrowIt",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
method.ThrowException(typeof(NotSupportedException));
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
private static void BuildFirstType(AssemblyDebugging assembly)
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"FirstClass"))
{
DebuggingWithTwoTypesTests.BuildMethodsInType(type);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("AssemblyWithOneTypeThatImplementsInterfacesWithNullReference"))
{
using (var type = DebuggingTests.CreateDebuggingType(assembly,
assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass", new HashSet <Type>()
{
typeof(IComparable), null, typeof(IDisposable)
}))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var compareToMethod = type.GetMethodDebugging(
type.Builder.DefineMethod("CompareTo",
MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public,
typeof(int), new Type[] { typeof(object) })))
{
compareToMethod.Emit(OpCodes.Ldc_I4_0);
compareToMethod.Emit(OpCodes.Ret);
var iCompareToMethod = typeof(IComparable).GetMethod("CompareTo");
type.Builder.DefineMethodOverride(compareToMethod.Builder, iCompareToMethod);
}
using (var disposeMethod = type.GetMethodDebugging(
type.Builder.DefineMethod("Dispose",
MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public)))
{
disposeMethod.Emit(OpCodes.Ret);
var iDisposeMethod = typeof(IDisposable).GetMethod("Dispose");
type.Builder.DefineMethodOverride(disposeMethod.Builder, iDisposeMethod);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("JustReturn",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("AssemblyWithTwoTypes"))
{
DebuggingWithTwoTypesTests.BuildFirstType(assembly);
DebuggingWithTwoTypesTests.BuildSecondType(assembly);
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatCreatesSwitch"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("GenerateSwitch",
MethodAttributes.HideBySig | MethodAttributes.Public,
typeof(string), new Type[] { typeof(int) })))
{
var defaultCase = method.DefineLabel();
var endOfMethod = method.DefineLabel();
method.Emit(OpCodes.Ldarg_1);
var jumpTable = new Label[] { method.DefineLabel(), method.DefineLabel() };
method.Emit(OpCodes.Switch, jumpTable);
method.Emit(OpCodes.Br_S, defaultCase);
method.MarkLabel(jumpTable[0]);
method.Emit(OpCodes.Ldstr, "It's zero.");
method.Emit(OpCodes.Br_S, endOfMethod);
method.MarkLabel(jumpTable[1]);
method.Emit(OpCodes.Ldstr, "It's one.");
method.Emit(OpCodes.Br_S, endOfMethod);
method.MarkLabel(defaultCase);
method.Emit(OpCodes.Ldstr, "It's something else.");
method.MarkLabel(endOfMethod);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected void RunTest(bool verifyAssembly)
{
var assemblyName = this.CreateAssemblyAndVerify(verifyAssembly);
DebuggingTests.AssertFileContents(this.GetExpectedFileLines(),
File.ReadAllLines(assemblyName + ".il"));
XmlPdbReader.Program.PdbToXML(assemblyName + ".pdb", assemblyName + ".xml");
this.AssertSequencePoints(new XPathDocument(assemblyName + ".xml").CreateNavigator());
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodWithTryCatchFault"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("Divide",
MethodAttributes.HideBySig | MethodAttributes.Public,
typeof(int), new Type[] { typeof(int), typeof(int) })))
{
method.DeclareLocal(typeof(int));
method.BeginExceptionBlock();
method.BeginExceptionBlock();
method.Emit(OpCodes.Ldarg_1);
method.Emit(OpCodes.Ldarg_2);
method.Emit(OpCodes.Div);
method.Emit(OpCodes.Stloc_0);
method.BeginCatchBlock(typeof(DivideByZeroException));
method.Emit(OpCodes.Ldc_I4_S, 22);
method.Emit(OpCodes.Stloc_0);
method.BeginCatchBlock(typeof(ArgumentException));
method.Emit(OpCodes.Ldc_I4_S, 20);
method.Emit(OpCodes.Stloc_0);
method.EndExceptionBlock();
method.BeginFaultBlock();
method.Emit(OpCodes.Ldc_I4_S, 21);
method.Emit(OpCodes.Stloc_0);
method.EndExceptionBlock();
method.Emit(OpCodes.Ldloc_0);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatCallsVarArgsMethod"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
MethodInfo varMethod = null;
using (var varArgsMethod = type.GetMethodDebugging(
type.Builder.DefineMethod("VarArgsMethod",
MethodAttributes.HideBySig | MethodAttributes.Public,
CallingConventions.VarArgs,
null, new Type[] { typeof(string) })))
{
varArgsMethod.Emit(OpCodes.Ret);
varMethod = varArgsMethod.Builder as MethodInfo;
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("CallVarArgsMethod",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
method.Emit(OpCodes.Ldarg_0);
method.Emit(OpCodes.Ldstr, "Param");
method.Emit(OpCodes.Ldstr, "VarArgParam");
method.Emit(OpCodes.Ldc_I4_1);
method.EmitCall(OpCodes.Call, varMethod,
new Type[] { typeof(string), typeof(int) });
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatUsesManagedCalli"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("Calli",
MethodAttributes.HideBySig | MethodAttributes.Public, null,
new Type[] { typeof(IntPtr) })))
{
method.Emit(OpCodes.Ldarg_1);
method.EmitCalli(OpCodes.Calli, CallingConventions.Standard | CallingConventions.HasThis,
typeof(int), new Type[] { typeof(long), typeof(string) }, null);
method.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("CalliVarArg",
MethodAttributes.HideBySig | MethodAttributes.Public, null,
new Type[] { typeof(IntPtr) })))
{
method.Emit(OpCodes.Ldarg_1);
method.EmitCalli(OpCodes.Calli, CallingConventions.VarArgs,
typeof(int), new Type[] { typeof(long), typeof(string) },
new Type[] { typeof(long), typeof(string) });
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodWithStoringIntegers"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("StoreIntegers",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
method.DeclareLocal(typeof(short));
method.DeclareLocal(typeof(int));
method.DeclareLocal(typeof(long));
method.DeclareLocal(typeof(byte));
method.Emit(OpCodes.Ldc_I4_S, (short)3);
method.Emit(OpCodes.Stloc_0);
method.Emit(OpCodes.Ldc_I4, 33);
method.Emit(OpCodes.Stloc_1);
method.Emit(OpCodes.Ldc_I8, 33L);
method.Emit(OpCodes.Stloc_2);
method.Emit(OpCodes.Ldc_I4_S, (byte)3);
method.Emit(OpCodes.Stloc_3);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodUsingNamespace"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("UsingNamespace",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
var outerLocal = method.DeclareLocal(typeof(int));
method.Emit(OpCodes.Ldc_I4_3);
method.Emit(OpCodes.Stloc, outerLocal);
method.BeginScope();
method.UsingNamespace("quux");
var innerLocal = method.DeclareLocal(typeof(long));
method.Emit(OpCodes.Ldloc, outerLocal);
method.Emit(OpCodes.Conv_I8);
method.Emit(OpCodes.Stloc, innerLocal);
method.EndScope();
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected static AssemblyDebugging CreateDebuggingAssembly(string name)
{
var assemblyName = new AssemblyName();
assemblyName.Name = name;
var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
assemblyName, AssemblyBuilderAccess.Save);
DebuggingTests.AddDebuggingAttribute(assembly);
var module = assembly.DefineDynamicModule(assemblyName.Name,
assemblyName.Name + ".dll", true);
var symbolWriter = module.DefineDocument(
assemblyName.Name + ".il", SymDocumentType.Text,
SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
return(new AssemblyDebugging(assemblyName.Name + ".il", assembly, symbolWriter));
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodWithBreakingToLabel"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("BreakToLabel",
MethodAttributes.HideBySig | MethodAttributes.Public,
typeof(int), new Type[] { typeof(bool) })))
{
var trueValue = method.DefineLabel();
var end = method.DefineLabel();
method.Emit(OpCodes.Ldarg_1);
method.Emit(OpCodes.Brtrue_S, trueValue);
method.Emit(OpCodes.Ldc_I4_0);
method.Emit(OpCodes.Br_S, end);
method.MarkLabel(trueValue);
method.Emit(OpCodes.Ldc_I4_1);
method.MarkLabel(end);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatUsesSignatureHelper"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
ctor.Emit(OpCodes.Ldarg_0);
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("CallViaHelper",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
var helper = SignatureHelper.GetMethodSigHelper(
assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
CallingConventions.Standard, null);
method.Emit(OpCodes.Calli, helper);
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatWritesLotsOfLocalsToTheConsole"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Ldarg_0);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("WriteToConsole",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
for (var i = 0; i < 5; i++)
{
method.EmitWriteLine(method.DeclareLocal(typeof(int)));
}
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
protected override AssemblyDebugging CreateAssembly()
{
using (var assembly = DebuggingTests.CreateDebuggingAssembly("MethodThatWritesToTheConsole"))
{
using (var type = DebuggingTests.CreateDebuggingType(
assembly, assembly.Builder.GetDynamicModule(assembly.Builder.GetName().Name),
"SimpleClass"))
{
var intField = type.Builder.DefineField("guidFieldToWrite",
typeof(int),
FieldAttributes.Private | FieldAttributes.Static);
var stringField = type.Builder.DefineField("stringFieldToWrite",
typeof(string),
FieldAttributes.Private);
var randomField = type.Builder.DefineField("randomFieldToWrite",
typeof(Random),
FieldAttributes.Private);
using (var ctor = type.GetMethodDebugging(
type.Builder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, Type.EmptyTypes)))
{
var objectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Ldarg_0);
ctor.Emit(OpCodes.Call, objectCtor);
ctor.Emit(OpCodes.Ldarg_0);
ctor.Emit(OpCodes.Ldstr, "data");
ctor.Emit(OpCodes.Stfld, stringField);
ctor.Emit(OpCodes.Ldc_I4_3);
ctor.Emit(OpCodes.Stsfld, intField);
ctor.Emit(OpCodes.Ldarg_0);
var randomCtor = typeof(Random).GetConstructor(Type.EmptyTypes);
ctor.Emit(OpCodes.Newobj, randomCtor);
ctor.Emit(OpCodes.Stfld, randomField);
ctor.Emit(OpCodes.Ret);
}
using (var method = type.GetMethodDebugging(
type.Builder.DefineMethod("WriteToConsole",
MethodAttributes.HideBySig | MethodAttributes.Public)))
{
var stringLocal = method.DeclareLocal(typeof(string));
var intLocal = method.DeclareLocal(typeof(int));
var randomLocal = method.DeclareLocal(typeof(Random));
method.EmitWriteLine(stringLocal);
method.EmitWriteLine(intLocal);
method.EmitWriteLine(randomLocal);
method.EmitWriteLine(stringField);
method.EmitWriteLine(intField);
method.EmitWriteLine(randomField);
method.EmitWriteLine("some data");
method.Emit(OpCodes.Ret);
}
type.Builder.CreateType();
}
return(assembly);
}
}
