public static string GetDisplayValue(this ClrInstanceField self, ClrValueClass clrObject) { if (self.IsObjectReference) { var obj = clrObject.GetObjectField(self.Name); if (obj.IsNull) { return("null"); } return($"0x{obj.Address:X} [{obj.Type.Name}:0x{obj.Type.MethodTable:X}]"); } else if (self.HasSimpleValue) { return($"{self.GetValue(clrObject.Address)} [{self.Type.Name}]"); } else if (self.IsValueClass) { var vt = clrObject.GetValueClassField(self.Name); return($"0x{vt.Address:X} [struct {vt.Type.Name}:0x{vt.Type.MethodTable:X}]"); } else { return("<unknown value>"); } }
public void Equals_WhenDifferentAddress_ReturnsFalse([Frozen] ClrType type, ClrValueClass uno, ClrValueClass dos) { // Act var areSame = uno.Equals(dos); // Assert areSame.Should().BeFalse(); }
private static bool ExtractStruct(Pair p, ClrInstanceField field, ClrValueClass structClass, out object result) { result = null; Type type; if (!GetType(p, field.Type, out type)) { return(false); } var fieldInfos = GetFields(type); result = FormatterServices.GetUninitializedObject(type); foreach (var fld in structClass.Type.Fields) { object value = null; if (fld.Type.IsString) { value = structClass.GetStringField(fld.Name); } else if (fld.Type.IsPrimitive) { value = fld.GetValue(structClass.Address, true); } else if (fld.Type.IsValueClass) { if (!ExtractStruct(p, fld, structClass.GetValueClassField(fld.Name), out value)) { continue; } } else if (fld.Type.IsArray) { Array arr = null; if (!ExtractArray(p, structClass.GetObjectField(fld.Name), fld, out arr)) { continue; } value = arr; } else { if (!ExtractRefObject(p, field, structClass.GetObjectField(fld.Name), out value)) { continue; } } fieldInfos[fld.Name].SetValue(result, value); } return(true); }
public void GetValueClassField_WhenFieldFound_ReturnsField(ClrValueClass target, [Frozen] ClrType structType, ClrValueClass someStruct, ClrInstanceField structValueField) { // Arrange structValueField.IsValueClass.Returns(true); structValueField.Type.Returns(target.Type); structValueField.GetAddress(someStruct.Address, Arg.Any <bool>()).Returns(target.Address); // Act var structRefFieldTarget = someStruct.GetValueClassField(structValueField.Name); // Assert structRefFieldTarget.Equals(target).Should().BeTrue(); }
public void GetFieldFrom_WhenStructureHasStructureField_ReturnsField(ClrValueClass target, [Frozen] ClrType structType, ClrValueClass rawStruct, ClrInstanceField structValueField) { // Arrange IAddressableTypedEntity entity = rawStruct; structValueField.IsValueClass.Returns(true); structValueField.Type.Returns(entity.Type); structValueField.GetAddress(entity.Address, Arg.Any <bool>()).Returns(target.Address); // Act var structFromStruct = entity.GetFieldFrom(structValueField.Name); // Assert structFromStruct.Address.Should().Be(target.Address); }
public void GetFieldFrom_WhenFieldFound_ReturnsField([Frozen] ClrHeap heap, ClrValueClass target, [Frozen] ClrType clrObjectType, ClrObject rawClrObject, ClrInstanceField clrObjValueField) { clrObjValueField.IsValueClass.Returns(true); clrObjValueField.Type.Returns(target.Type); clrObjValueField .GetAddress(rawClrObject.Address) .Returns(target.Address); // Act var structRefFieldTarget = rawClrObject.GetFieldFrom(clrObjValueField.Name); // Assert structRefFieldTarget.Equals(target).Should().BeTrue(); }
public static Pair ExtractStructFields(Pair p) { var obj = p.ClrObj; foreach (var field in obj.Type.Fields.Where(field => field.IsValueClass)) { ClrValueClass structClass = obj.GetValueClassField(field.Name); object result; if (!ExtractStruct(p, field, structClass, out result)) { continue; } p.FieldInfo[field.Name].SetValue(p.RuntimeObject, result); } return(p); }
public void GetFieldFrom_WhenStructureHasReferenceField_ReturnsField([Frozen] ClrHeap heap, ClrObject target, [Frozen] ClrType structType, ClrValueClass rawStruct, ClrInstanceField structReferenceField, ulong fieldAddress) { // Arrange IAddressableTypedEntity entity = rawStruct; structReferenceField.IsObjectReference.Returns(true); structReferenceField.GetAddress(entity.Address, Arg.Any <bool>()).Returns(fieldAddress); heap.ReadPointer(fieldAddress, out var whatever) .Returns(call => { call[1] = target.Address; return(true); }); // Act var fieldByName = entity.GetFieldFrom(structReferenceField.Name); // Assert fieldByName.Address.Should().Be(target.Address); }
public void GetObjectField_WhenFieldFound_ReturnsField([Frozen] ClrHeap heap, ClrObject target, [Frozen] ClrType structType, ClrValueClass someStruct, ClrInstanceField structReferenceField, ulong fieldAddress) { // Arrange structReferenceField.IsObjectReference.Returns(true); structReferenceField.GetAddress(someStruct.Address, Arg.Any <bool>()).Returns(fieldAddress); heap.ReadPointer(fieldAddress, out var whatever) .Returns(call => { call[1] = target.Address; return(true); }); // Act var structRefFieldTarget = someStruct.GetObjectField(structReferenceField.Name); // Assert structRefFieldTarget.Should().Be(target); }
public void Equals_WhenSameAddressAndTypes_ReturnsTrue([Frozen] ulong address, [Frozen] ClrType type, ClrValueClass uno, ClrValueClass dos) { // Act var areSame = uno.Equals(dos); // Assert areSame.Should().BeTrue(); }
/// <summary> /// Initializes a new instance of the <see cref="ClrValueClassAdapter" /> class. /// </summary> /// <param name="valueClass">The value class.</param> /// <inheritdoc /> public ClrValueClassAdapter(IConverter converter, ClrValueClass valueClass) : base(converter) { ValueClass = valueClass; Address = ValueClass.Address; }