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;
}
