public void FieldNameAndValueTests()
{
// TODO: test reading structs from instance/static fields
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrType fooType = runtime.GetModule("sharedlibrary.dll").GetTypeByName("Foo");
ClrObject obj = runtime.GetModule(ModuleName).GetTypeByName("Types").GetStaticFieldByName("s_foo").ReadObject(domain);
if (dt.CacheOptions.CacheTypes)
{
Assert.Same(fooType, obj.Type);
Assert.Same(fooType, heap.GetObjectType(obj.Address));
}
else
{
Assert.Equal(fooType, obj.Type);
Assert.Equal(fooType, heap.GetObjectType(obj.Address));
}
TestFieldNameAndValue(fooType, obj, "i", 42);
TestFieldNameAndValue(fooType, obj, "s", "string");
TestFieldNameAndValue(fooType, obj, "b", true);
TestFieldNameAndValue(fooType, obj, "f", 4.2f);
TestFieldNameAndValue(fooType, obj, "d", 8.4);
}
public void ModuleDomainTest()
{
using DataTarget dt = TestTargets.AppDomains.LoadFullDump();
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrAppDomain appDomainExe = runtime.GetDomainByName("AppDomains.exe");
ClrAppDomain nestedDomain = runtime.GetDomainByName("Second AppDomain");
ClrModule mscorlib = runtime.GetModule("mscorlib.dll");
AssertModuleContainsDomains(mscorlib, runtime.SharedDomain, appDomainExe, nestedDomain);
AssertModuleDoesntContainDomains(mscorlib, runtime.SystemDomain);
// SharedLibrary.dll is loaded into both domains but not as shared library like mscorlib.
// This means it will not be in the shared domain.
ClrModule sharedLibrary = runtime.GetModule("sharedlibrary.dll");
AssertModuleContainsDomains(sharedLibrary, appDomainExe, nestedDomain);
AssertModuleDoesntContainDomains(sharedLibrary, runtime.SharedDomain, runtime.SystemDomain);
ClrModule appDomainsExeModule = runtime.GetModule("AppDomains.exe");
AssertModuleContainsDomains(appDomainsExeModule, appDomainExe);
AssertModuleDoesntContainDomains(appDomainsExeModule, runtime.SystemDomain, runtime.SharedDomain, nestedDomain);
ClrModule nestedExeModule = runtime.GetModule("NestedException.exe");
AssertModuleContainsDomains(nestedExeModule, nestedDomain);
AssertModuleDoesntContainDomains(nestedExeModule, runtime.SystemDomain, runtime.SharedDomain, appDomainExe);
}
public void TestHasPdb()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule types = runtime.GetModule(TypeTests.ModuleName);
Assert.NotNull(types.Pdb);
ClrModule shared = runtime.GetModule("sharedlibrary.dll");
Assert.NotNull(shared.Pdb);
}
public void AsEnumTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule typesModule = runtime.GetModule(ModuleName);
ClrType type = typesModule.GetTypeByName("Types");
ClrStaticField field = type.GetStaticFieldByName("s_enum");
Assert.True(field.Type.IsEnum);
ClrEnum clrEnum = field.Type.AsEnum();
Assert.NotNull(clrEnum);
string[] propertyNames = clrEnum.GetEnumNames().ToArray();
Assert.NotEmpty(propertyNames);
Assert.Contains(nameof(FileAccess.Read), propertyNames);
Assert.Contains(nameof(FileAccess.Write), propertyNames);
Assert.Contains(nameof(FileAccess.ReadWrite), propertyNames);
Assert.Equal(ClrElementType.Int32, clrEnum.ElementType);
Assert.Equal(FileAccess.Read, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.Read)));
Assert.Equal(FileAccess.Write, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.Write)));
Assert.Equal(FileAccess.ReadWrite, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.ReadWrite)));
}
public void TestGetTypeByName()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrModule shared = runtime.GetModule("sharedlibrary.dll");
Assert.NotNull(shared.GetTypeByName("Foo"));
Assert.Null(shared.GetTypeByName("Types"));
ClrModule types = runtime.GetModule(TypeTests.ModuleName);
Assert.NotNull(types.GetTypeByName("Types"));
Assert.Null(types.GetTypeByName("Foo"));
}
public void IntegerObjectClrType()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrModule module = runtime.GetModule(ModuleName);
ClrType typesType = module.GetTypeByName("Types");
ClrStaticField field = typesType.GetStaticFieldByName("s_i");
ClrObject obj = field.ReadObject(domain);
Assert.False(obj.IsNull);
ClrType type = obj.Type;
Assert.NotNull(type);
Assert.True(type.IsPrimitive);
Assert.False(type.IsObjectReference);
Assert.True(type.IsValueType);
var fds = obj.Type.Fields;
Assert.True(obj.IsBoxedValue);
int value = obj.ReadBoxedValue <int>();
Assert.Equal(42, value);
Assert.Contains(obj.Address, heap.EnumerateObjects().Select(a => a.Address));
}
public void ArrayReferenceEnumeration()
{
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrModule typesModule = runtime.GetModule("types.exe");
ClrType type = heap.GetTypeByName("Types");
ulong s_array = (ulong)type.GetStaticFieldByName("s_array").GetValue(domain);
ulong s_one = (ulong)type.GetStaticFieldByName("s_one").GetValue(domain);
ulong s_two = (ulong)type.GetStaticFieldByName("s_two").GetValue(domain);
ulong s_three = (ulong)type.GetStaticFieldByName("s_three").GetValue(domain);
ClrType arrayType = heap.GetObjectType(s_array);
List <ulong> objs = new List <ulong>();
arrayType.EnumerateRefsOfObject(s_array, (obj, offs) => objs.Add(obj));
// We do not guarantee the order in which these are enumerated.
Assert.Equal(3, objs.Count);
Assert.Contains(s_one, objs);
Assert.Contains(s_two, objs);
Assert.Contains(s_three, objs);
}
}
public void MethodHandleMultiDomainTests()
{
ulong[] methodDescs;
using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod method = type.GetMethod("Bar");
methodDescs = method.EnumerateMethodDescs().ToArray();
Assert.AreEqual(2, methodDescs.Length);
}
using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrMethod method = runtime.GetMethodByHandle(methodDescs[0]);
Assert.IsNotNull(method);
Assert.AreEqual("Bar", method.Name);
Assert.AreEqual("Foo", method.Type.Name);
}
using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrMethod method = runtime.GetMethodByHandle(methodDescs[1]);
Assert.IsNotNull(method);
Assert.AreEqual("Bar", method.Name);
Assert.AreEqual("Foo", method.Type.Name);
}
}
public void ArrayOffsetsTest()
{
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrModule typesModule = runtime.GetModule("types.exe");
ClrType type = heap.GetTypeByName("Types");
ulong s_array = (ulong)type.GetStaticFieldByName("s_array").GetValue(domain);
ulong s_one = (ulong)type.GetStaticFieldByName("s_one").GetValue(domain);
ulong s_two = (ulong)type.GetStaticFieldByName("s_two").GetValue(domain);
ulong s_three = (ulong)type.GetStaticFieldByName("s_three").GetValue(domain);
ulong[] expected = new ulong[] { s_one, s_two, s_three };
ClrType arrayType = heap.GetObjectType(s_array);
for (int i = 0; i < expected.Length; i++)
{
Assert.Equal(expected[i], (ulong)arrayType.GetArrayElementValue(s_array, i));
ulong address = arrayType.GetArrayElementAddress(s_array, i);
ulong value = dt.DataReader.ReadPointerUnsafe(address);
Assert.NotEqual(0ul, address);
Assert.Equal(expected[i], value);
}
}
}
public void NoTypeCachingTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
dt.CacheOptions.CacheTypes = false;
dt.CacheOptions.CacheTypeNames = StringCaching.None;
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
Assert.NotEqual(0ul, type.MethodTable); // Sanity test
ClrType type2 = runtime.GetTypeByMethodTable(type.MethodTable);
Assert.Equal(type, type2);
Assert.NotSame(type, type2);
Assert.NotNull(type.Name);
Assert.Equal(type.Name, type.Name);
Assert.NotSame(type.Name, type.Name);
dt.CacheOptions.CacheTypeNames = StringCaching.Intern;
Assert.Same(type.Name, type.Name);
Assert.Same(type.Name, string.Intern(type.Name));
}
public void MethodCachingTest()
{
// Test that when we cache method names they are not re-read
using DataTarget dt = TestTargets.Types.LoadFullDump();
dt.CacheOptions.CacheMethods = true;
// We want to make sure we are getting the same string because it was cached,
// not because it was interned
dt.CacheOptions.CacheMethodNames = StringCaching.Cache;
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod method = type.GetMethod("Bar");
Assert.NotEqual(0ul, method.MethodDesc); // Sanity test
ClrMethod method2 = type.GetMethod("Bar");
Assert.Equal(method, method2);
Assert.Same(method, method2);
string signature1 = method.Signature;
string signature2 = method2.Signature;
Assert.NotNull(signature1);
Assert.Equal(signature1, signature2);
Assert.Equal(signature1, method.Signature);
Assert.Same(signature1, method.Signature);
}
public void NoFieldCachingTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
dt.CacheOptions.CacheFields = false;
dt.CacheOptions.CacheFieldNames = StringCaching.None;
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
Assert.NotEqual(0ul, type.MethodTable); // Sanity test
Assert.NotEqual(type.Fields, type.Fields);
ClrField field = type.GetFieldByName("o");
ClrField field2 = type.Fields.Single(f => f.Name == "o");
Assert.NotSame(field, field2);
Assert.NotSame(field.Name, field.Name);
dt.CacheOptions.CacheFieldNames = StringCaching.Intern;
Assert.Same(field.Name, field.Name);
Assert.Same(field.Name, string.Intern(field.Name));
}
public void InnerStructSizeTest()
{
// https://github.com/microsoft/clrmd/issues/101
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule sharedLibrary = runtime.GetModule("sharedlibrary.dll");
ClrType structTestClass = sharedLibrary.GetTypeByName("StructTestClass");
ClrType structTest = sharedLibrary.GetTypeByName("Struct");
Assert.NotNull(structTest);
ClrInstanceField field = structTestClass.GetFieldByName("s");
if (dt.CacheOptions.CacheTypes)
{
Assert.Same(structTest, field.Type);
}
else
{
Assert.Equal(structTest, field.Type);
}
Assert.Equal(sizeof(int), field.Size);
ClrInstanceField nes = structTestClass.GetFieldByName("nes");
Assert.Equal(0, nes.Size);
ClrInstanceField es = nes.Type.GetFieldByName("es");
Assert.Equal(0, es.Size);
}
public void FieldNameAndValueTests()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrType fooType = runtime.GetModule("sharedlibrary.dll").GetTypeByName("Foo");
ulong obj = (ulong)runtime.GetModule("types.exe").GetTypeByName("Types").GetStaticFieldByName("s_foo").GetValue(runtime.AppDomains.Single());
Assert.Same(fooType, heap.GetObjectType(obj));
TestFieldNameAndValue(fooType, obj, "i", 42);
TestFieldNameAndValue(fooType, obj, "s", "string");
TestFieldNameAndValue(fooType, obj, "b", true);
TestFieldNameAndValue(fooType, obj, "f", 4.2f);
TestFieldNameAndValue(fooType, obj, "d", 8.4);
}
public void CorElementType()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrType classType = runtime.GetModule("sharedlibrary.dll").GetTypeByName("Foo");
ClrType arrayType = runtime.BaseClassLibrary.GetTypeByName("System.Array");
Assert.Equal(ClrElementType.Class, classType.ElementType);
Assert.Equal(ClrElementType.Class, arrayType.ElementType);
}
public void CompleteSignatureIsRetrievedForMethodsWithGenericParameters()
{
using DataTarget dt = TestTargets.AppDomains.LoadFullDump();
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod genericMethod = type.GetMethod("GenericBar");
string methodName = genericMethod.GetFullSignature();
Assert.Equal(')', methodName.Last());
}
public void GenericTypeTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrType genericType = runtime.GetModule("sharedlibrary.dll").GetTypeByName("GenericClass<T1, T2, T3, T4, T5>");
ClrGenericParameter[] genericParameters = genericType.EnumerateGenericParameters().ToArray();
Assert.Equal(5, genericParameters.Length);
VerifyGenericParameter(genericParameters, 0, "T1");
VerifyGenericParameter(genericParameters, 1, "T2");
VerifyGenericParameter(genericParameters, 2, "T3");
VerifyGenericParameter(genericParameters, 3, "T4");
VerifyGenericParameter(genericParameters, 4, "T5");
public void ArrayLengthTest()
{
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrAppDomain domain = runtime.AppDomains.Single();
ClrModule typesModule = runtime.GetModule("types.exe");
ClrType type = heap.GetTypeByName("Types");
ulong s_array = (ulong)type.GetStaticFieldByName("s_array").GetValue(domain);
ClrType arrayType = heap.GetObjectType(s_array);
Assert.Equal(3, arrayType.GetArrayLength(s_array));
}
}
public void InstanceFieldProperties()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrType foo = runtime.GetModule("sharedlibrary.dll").GetTypeByName("Foo");
Assert.NotNull(foo);
CheckField(foo, "i", ClrElementType.Int32, "System.Int32", 4);
CheckField(foo, "s", ClrElementType.String, "System.String", IntPtr.Size);
CheckField(foo, "b", ClrElementType.Boolean, "System.Boolean", 1);
CheckField(foo, "f", ClrElementType.Float, "System.Single", 4);
CheckField(foo, "d", ClrElementType.Double, "System.Double", 8);
CheckField(foo, "o", ClrElementType.Object, "System.Object", IntPtr.Size);
}
public void IsDelegateTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
ClrType type = typesModule.GetTypeByName("Types");
ClrObject TestDelegate = type.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single());
Assert.True(TestDelegate.IsValid);
Assert.True(TestDelegate.IsDelegate);
Assert.False(TestDelegate.AsDelegate().HasMultipleTargets);
ClrObject TestEvent = type.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single());
Assert.True(TestEvent.IsValid);
Assert.True(TestEvent.IsDelegate);
Assert.True(TestEvent.AsDelegate().HasMultipleTargets);
}
public void TestTypeModifiers()
{
using DataTarget dt = TestTargets.NestedTypes.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule(NestedTypesModuleName);
ClrType program = module.GetTypeByName("Program");
Assert.True(program.IsPublic);
Assert.False(program.IsAbstract);
Assert.False(program.IsSealed);
ClrType publicClass = module.GetTypeByName("Program+PublicClass");
Assert.True(publicClass.IsPublic);
ClrType privateClass = module.GetTypeByName("Program+PrivateClass");
Assert.True(privateClass.IsPrivate);
ClrType internalClass = module.GetTypeByName("Program+InternalClass");
Assert.True(internalClass.IsInternal);
ClrType protectedClass = module.GetTypeByName("Program+ProtectedClass");
Assert.True(protectedClass.IsProtected);
ClrType abstractClass = module.GetTypeByName("Program+AbstractClass");
Assert.True(abstractClass.IsAbstract);
Assert.False(abstractClass.IsSealed);
ClrType sealedClass = module.GetTypeByName("Program+SealedClass");
Assert.True(sealedClass.IsSealed);
Assert.False(sealedClass.IsAbstract);
ClrType staticClass = module.GetTypeByName("Program+StaticClass");
Assert.True(staticClass.IsAbstract);
Assert.True(staticClass.IsSealed);
}
public void GetDelegateTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
ClrType Types = typesModule.GetTypeByName("Types");
ClrDelegate TestDelegate = Types.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single()).AsDelegate();
ClrDelegateTarget delegateTarget = TestDelegate.GetDelegateTarget();
Assert.NotNull(delegateTarget);
CompareToInner(Types, TestDelegate, delegateTarget);
ClrDelegate TestEvent = Types.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single()).AsDelegate();
ClrDelegateTarget eventTarget = TestEvent.GetDelegateTarget();
Assert.Null(eventTarget);
}
public void ComponentTypeEventuallyFilledTest()
{
// https://github.com/microsoft/clrmd/issues/108
// Ensure that a previously created type with a erronous null ComponentType eventually
// gets its ComponentType set.
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrType fooType = runtime.GetModule(ModuleName).GetTypeByName("Types");
ClrStaticField cq = fooType.GetStaticFieldByName("s_cq");
Assert.NotNull(cq);
ClrInstanceField m_head = cq.Type.GetFieldByName("m_head");
ClrInstanceField m_array = m_head.Type.GetFieldByName("m_array");
bool hasSimpleValue = m_array.HasSimpleValue;
ClrElementType elementType = m_array.ElementType;
ClrType componentType = m_array.Type.ComponentType;
// If this assert fails, remove the test. This value is null because currently CLR's
// debugging layer doesn't tell us the component type of an array. If we eventually
// fix that issue, we would return a non-null m_array.Type.ComponentType, causing
// this test to fail but the underlying issue would be fixed.
Assert.Null(componentType);
ClrObject m_arrayObj = cq.ReadObject().GetObjectField("m_head").GetObjectField("m_array");
// Ensure we are looking at the same ClrType
if (dt.CacheOptions.CacheTypes)
{
Assert.Same(m_array.Type, m_arrayObj.Type);
}
else
{
Assert.Equal(m_array.Type, m_arrayObj.Type);
}
// Assert that we eventually filled in ComponentType after we got a real object for the type
Assert.NotNull(m_arrayObj.Type.ComponentType);
}
public void NoMethodCachingTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
dt.CacheOptions.CacheMethods = false;
dt.CacheOptions.CacheMethodNames = StringCaching.None;
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod method = type.GetMethod("Bar");
Assert.NotEqual(0ul, method.MethodDesc); // Sanity test
ClrMethod method2 = type.GetMethod("Bar");
Assert.Equal(method, method2);
Assert.NotSame(method, method2);
string signature1 = method.Signature;
string signature2 = method2.Signature;
Assert.NotNull(signature1);
Assert.Equal(signature1, signature2);
Assert.Equal(signature1, method.Signature);
Assert.NotSame(signature1, method.Signature);
Assert.NotSame(method2.Signature, method.Signature);
// Ensure that we can swap this at runtime and that we get interned strings
dt.CacheOptions.CacheMethodNames = StringCaching.Intern;
Assert.NotNull(method.Signature);
Assert.Same(method2.Signature, method.Signature);
Assert.Same(method.Signature, string.Intern(method.Signature));
}
public void IntegerObjectClrType()
{
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrHeap heap = runtime.Heap;
ClrStaticField field = runtime.GetModule("types.exe").GetTypeByName("Types").GetStaticFieldByName("s_i");
ulong addr = (ulong)field.GetValue(runtime.AppDomains.Single());
ClrType type = heap.GetObjectType(addr);
Assert.True(type.IsPrimitive);
Assert.False(type.IsObjectReference);
Assert.False(type.IsValueClass);
object value = type.GetValue(addr);
Assert.Equal("42", value.ToString());
Assert.IsType <int>(value);
Assert.Equal(42, (int)value);
Assert.Contains(addr, heap.EnumerateObjectAddresses());
}
}
public void EnumerateDelegateTest()
{
using DataTarget dt = TestTargets.Types.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
ClrType Types = typesModule.GetTypeByName("Types");
ClrDelegate TestDelegate = Types.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single()).AsDelegate();
ClrDelegateTarget[] methods = TestDelegate.EnumerateDelegateTargets().ToArray();
Assert.Single(methods);
CompareToInner(Types, TestDelegate, methods[0]);
ClrDelegate TestEvent = Types.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single()).AsDelegate();
methods = TestEvent.EnumerateDelegateTargets().ToArray();
Assert.Equal(2, methods.Length);
CompareToInner(Types, TestEvent, methods[0]);
CompareToInstanceMethod(Types, TestEvent, methods[1]);
}
public void MethodHandleSingleDomainTests()
{
ulong methodDesc;
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod method = type.GetMethod("Bar");
methodDesc = method.MethodDesc;
Assert.NotEqual(0ul, methodDesc);
}
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrMethod method = runtime.GetMethodByHandle(methodDesc);
Assert.NotNull(method);
Assert.Equal("Bar", method.Name);
Assert.Equal("Foo", method.Type.Name);
}
using (DataTarget dt = TestTargets.Types.LoadFullDump())
{
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule("sharedlibrary.dll");
ClrType type = module.GetTypeByName("Foo");
ClrMethod method = type.GetMethod("Bar");
Assert.Equal(methodDesc, method.MethodDesc);
Assert.Equal(method, runtime.GetMethodByHandle(methodDesc));
}
}
public void TestStaticFieldModifiers()
{
using DataTarget dt = TestTargets.NestedTypes.LoadFullDump();
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
ClrModule module = runtime.GetModule(TypeTests.NestedTypesModuleName);
ClrType program = module.GetTypeByName("Program");
ClrStaticField publicField = program.GetStaticFieldByName("s_publicField");
Assert.True(publicField.IsPublic);
ClrStaticField privateField = program.GetStaticFieldByName("s_privateField");
Assert.True(privateField.IsPrivate);
ClrStaticField internalField = program.GetStaticFieldByName("s_internalField");
Assert.True(internalField.IsInternal);
ClrStaticField protectedField = program.GetStaticFieldByName("s_protectedField");
Assert.True(protectedField.IsProtected);
}
