public void SetUp()
{
logSpy = new LogSpy();
logSpy.Attach();
childValues = new int[] { 20, 21, 22, 23, 24 };
remoteValue = RemoteValueFakeUtil.CreateSimpleIntArray("myArray", childValues);
ulong elementSize = 4;
var pointeeType = new SbTypeStub("int", TypeFlags.IS_INTEGER);
pointeeType.SetByteSize(elementSize);
var pointerType = new SbTypeStub("int*", TypeFlags.IS_POINTER, pointeeType);
ulong address = 1234;
pointerValue = RemoteValueFakeUtil.CreatePointer("int*", "myPtr", $"{address}");
pointerValue.SetTypeInfo(pointerType);
for (uint i = 0; i < 5; i++)
{
pointerValue.SetCreateValueFromAddress(
address + i * elementSize,
RemoteValueFakeUtil.CreateSimpleInt($"[{i}]", (int)(i) + 20));
}
}
public void PointerValues(string address, bool isTruthy)
{
var remoteValue = RemoteValueFakeUtil.CreatePointer("MyType*", "myVar", address);
var varInfo = varInfoBuilder.Create(remoteValue);
Assert.That(varInfo.IsTruthy, Is.EqualTo(isTruthy));
}
public void IsNullPointerReturnsTrueIfHexValueIsZero(
[Values("0X0000000000", "0x0000000000", "000000000")] string address)
{
var remoteValue = RemoteValueFakeUtil.CreatePointer("MyType", "myType", address);
var varInfo = CreateVarInfo(remoteValue, "myType");
Assert.That(varInfo.IsNullPointer(), Is.True);
}
public void IsNullPointerReturnsFalseIfHexValueIsNotZero(
[Values("0x0000032234", "0x00F0A32234")] string address)
{
var remoteValue = RemoteValueFakeUtil.CreatePointer("MyType", "myType", address);
var varInfo = CreateVarInfo(remoteValue, "myType");
Assert.That(varInfo.IsNullPointer(), Is.False);
}
void CheckPointerFormat(string formatSpecifier, int valueInt, string expectedValue)
{
var remoteValue = RemoteValueFakeUtil.CreatePointer("int*", "int", valueInt.ToString());
IRemoteValueFormat format = RemoteValueFormatProvider.Get(formatSpecifier);
Assert.AreEqual(format.FormatValueAsAddress(remoteValue), expectedValue);
Assert.IsTrue(format.ShouldInheritFormatSpecifier());
}
public void Pointer()
{
RemoteValue remoteValue =
RemoteValueFakeUtil.CreatePointer("dummyType*", "dummyName", "0xDEADC0DE");
Assert.That(RemoteValueExtensions.GetMemoryContextAddress(remoteValue),
Is.EqualTo(0xDEADC0DE));
}
public void Pointer()
{
RemoteValueFake remoteValue =
RemoteValueFakeUtil.CreatePointer("dummyType*", "dummyName", "0xDEADC0DE");
remoteValue.SetAddressOf(RemoteValueFakeUtil.CreateAddressOf(remoteValue, 0xDEAD0000));
Assert.That(RemoteValueExtensions.GetMemoryAddressAssignExpression(remoteValue),
Is.EqualTo("((dummyType*)0xDEADC0DE)"));
}
public void TestGetChildren_Pointer_NoPointee()
{
const int requestedArraySize = 3;
RemoteValueFormat format = GetFormat(requestedArraySize);
var pointerValueNoPointee = RemoteValueFakeUtil.CreatePointer("C*", "pc", "1234");
List <RemoteValue> result =
format.GetChildren(pointerValueNoPointee, 1, requestedArraySize).ToList();
Assert.That(result.Count(), Is.EqualTo(0));
}
public void DereferencePointer()
{
var remoteValue = RemoteValueFakeUtil.CreatePointer("int*", "xPtr", _memAddress);
var pointee = RemoteValueFakeUtil.CreateSimpleInt("x", 1);
remoteValue.SetDereference(pointee);
var varInfo = _varInfoFactory.Create(remoteValue);
Assert.That(remoteValue.Dereference(), Is.EqualTo(pointee));
}
public async Task Build_PointerClassValueAsync()
{
string address = $"0x{_pointerAddress:x16}";
RemoteValueFake pointer =
RemoteValueFakeUtil.CreatePointer("C*", "pc", _pointerAddress.ToString());
pointer.AddChild(RemoteValueFakeUtil.CreateSimpleInt("f", 42));
pointer.AddChild(RemoteValueFakeUtil.CreateSimpleString("g", "\"s\""));
IVariableInformation varInfo = CreateVarInfo(pointer, "");
string result = await ValueStringBuilder.BuildAsync(varInfo);
Assert.That(result, Is.EqualTo($"0x{_pointerAddress:x16} {{f=42 g=\"s\"}}"));
}
public async Task PointerMemberAccessAsync()
{
RemoteValueFake remoteValue =
RemoteValueFakeUtil.CreatePointer("MyType*", "myType", _memAddress);
remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleBool("value1", true));
remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleInt("value2", 22));
IVariableInformation varInfo = _varInfoFactory.Create(remoteValue);
IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync(
"value2", varInfo, new NatvisScope(), null);
Assert.That(exprVarInfo.DisplayName, Is.EqualTo("value2"));
Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("22"));
}
public void EvaluateExpressionWithErrorRemoteValue()
{
RemoteValueFake remoteValue =
RemoteValueFakeUtil.CreatePointer("MyType*", "myType", _memAddress);
remoteValue.AddValueFromExpression("myVal",
RemoteValueFakeUtil.CreateError("invalid expression"));
IVariableInformation varInfo = _varInfoFactory.Create(remoteValue);
var exception = Assert.ThrowsAsync <ExpressionEvaluationFailed>(
async() => await _evaluator.EvaluateExpressionAsync(
"myVal", varInfo, new NatvisScope(), "tmp"));
Assert.That(exception.Message, Does.Contain("myVal"));
}
public async Task ExpandFormatSpecifierReturnsChildAsync()
{
int[] grandChildValues = { 0, 1 };
var child = RemoteValueFakeUtil.CreateSimpleIntArray("arr", grandChildValues);
var remoteValue = RemoteValueFakeUtil.CreatePointer("int**", "ptr", _memAddress1);
remoteValue.AddChild(child);
var varInfo = CreateVarInfo(remoteValue, "expand(0)");
var children = await varInfo.GetAllChildrenAsync();
Assert.That(_logSpy.GetOutput(), Does.Not.Contain("ERROR"));
Assert.That(_logSpy.GetOutput(), Does.Not.Contain("WARNING"));
Assert.That(children.Length, Is.EqualTo(2));
Assert.That(await children[0].ValueAsync(), Is.EqualTo("0"));
Assert.That(await children[1].ValueAsync(), Is.EqualTo("1"));
}
public async Task PointerMemberAccessEvaluationAsync()
{
RemoteValueFake pointerValue =
RemoteValueFakeUtil.CreatePointer("MyType*", "pointer", _memAddress);
RemoteValueFake classValue =
RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue");
pointerValue.SetDereference(classValue);
classValue.AddValueFromExpression("field + 1",
RemoteValueFakeUtil.CreateSimpleInt("result", 23));
IVariableInformation varInfo = _varInfoFactory.Create(pointerValue);
IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync(
"field + 1", varInfo, new NatvisScope(), null);
Assert.That(exprVarInfo.DisplayName, Is.EqualTo("result"));
Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("23"));
}
public void SetUp()
{
_compRoot = new MediumTestDebugEngineFactoryCompRoot(new JoinableTaskContext());
_childValues = new int[] { 20, 21, 22, 23, 24 };
_remoteValue = RemoteValueFakeUtil.CreateSimpleIntArray("myArray", _childValues);
ulong elementSize = 4;
var pointeeType = new SbTypeStub("int", TypeFlags.IS_INTEGER);
pointeeType.SetByteSize(elementSize);
var pointerType = new SbTypeStub("int*", TypeFlags.IS_POINTER, pointeeType);
_pointerValue =
RemoteValueFakeUtil.CreatePointer("int*", "myPtr", $"{_pointerAddress}");
_pointerValue.SetTypeInfo(pointerType);
for (uint i = 0; i < 5; i++)
{
_pointerValue.SetCreateValueFromAddress(
_pointerAddress + i * elementSize,
RemoteValueFakeUtil.CreateSimpleInt($"[{i}]", (int)(i) + 20));
}
}