string GetExpressionPath(RemoteValueFake remoteValue)
{
string expressionPath;
Assert.True(remoteValue.GetExpressionPath(out expressionPath));
return(expressionPath);
}
public void GetExpressionPathComplexPointerAndNonPointer()
{
var value_10 = new RemoteValueFake("value", "10");
var value_20 = new RemoteValueFake("value", "20");
var next = new RemoteValueFake("next", "");
next.SetTypeInfo(
new SbTypeStub("LinkedListNode*", TypeFlags.IS_CLASS | TypeFlags.IS_POINTER));
next.AddChild(value_20);
var head = new RemoteValueFake("head", "");
head.SetTypeInfo(
new SbTypeStub("LinkedListNode*", TypeFlags.IS_CLASS | TypeFlags.IS_POINTER));
head.AddChild(next);
head.AddChild(value_10);
var list = new RemoteValueFake("list", "");
list.SetTypeInfo(new SbTypeStub("LinkedList", TypeFlags.IS_CLASS));
list.AddChild(head);
Assert.That(GetExpressionPath(list), Is.EqualTo("list"));
Assert.That(GetExpressionPath(head), Is.EqualTo("list.head"));
Assert.That(GetExpressionPath(value_10), Is.EqualTo("list.head->value"));
Assert.That(GetExpressionPath(value_20), Is.EqualTo("list.head->next->value"));
}
public void GetValueForExpressionPathComplexPointerAndNonPointer()
{
var value_10 = new RemoteValueFake("value", "10");
var value_20 = new RemoteValueFake("value", "20");
var next = new RemoteValueFake("next", "");
next.SetTypeInfo(
new SbTypeStub("LinkedListNod*", TypeFlags.IS_CLASS | TypeFlags.IS_POINTER));
next.AddChild(value_20);
var head = new RemoteValueFake("head", "");
head.SetTypeInfo(
new SbTypeStub("LinkedListNode*", TypeFlags.IS_CLASS | TypeFlags.IS_POINTER));
head.AddChild(next);
head.AddChild(value_10);
var list = new RemoteValueFake("list", "");
list.SetTypeInfo(new SbTypeStub("LinkedList", TypeFlags.IS_CLASS));
list.AddChild(head);
var h = list.GetValueForExpressionPath(".head");
var v10 = list.GetValueForExpressionPath(".head->value");
var n = list.GetValueForExpressionPath(".head->next");
var v20 = list.GetValueForExpressionPath(".head->next->value");
Assert.That(h, Is.SameAs(head));
Assert.That(v10, Is.SameAs(value_10));
Assert.That(n, Is.SameAs(next));
Assert.That(v20, Is.SameAs(value_20));
}
public static RemoteValueFake CreateSimpleString(string name, string val)
{
var remoteValue = new RemoteValueFake(name, val);
remoteValue.SetTypeInfo(new SbTypeStub("std::string", TypeFlags.IS_SCALAR));
return(remoteValue);
}
public static RemoteValueFake CreateError(string errorMessage, string name = "",
string value = "")
{
var errorValue = new RemoteValueFake(name, value);
errorValue.SetError(new SbErrorStub(false, errorMessage));
return(errorValue);
}
public static RemoteValueFake Create(string typename, TypeFlags typeFlags, string name,
string val)
{
var remoteValue = new RemoteValueFake(name, val.ToString());
remoteValue.SetTypeInfo(new SbTypeStub(typename, typeFlags));
return(remoteValue);
}
public void IsPointerWhenIsAnInstancePointer()
{
var remoteValue = new RemoteValueFake("varName", "value");
remoteValue.SetTypeInfo(new SbTypeStub("TypeName", TypeFlags.INSTANCE_IS_POINTER));
Assert.True(remoteValue.TypeIsPointerType());
}
public void IsPointerWhenNotAPointer()
{
var remoteValue = new RemoteValueFake("varName", "value");
remoteValue.SetTypeInfo(new SbTypeStub("TypeName", TypeFlags.NONE));
Assert.False(remoteValue.TypeIsPointerType());
}
public void GetTypeName()
{
var remoteValue = new RemoteValueFake("varName", "value");
remoteValue.SetTypeInfo(new SbTypeStub("TypeName", TypeFlags.NONE));
Assert.That(remoteValue.GetTypeName(), Is.EqualTo("TypeName"));
}
public static RemoteValueFake CreateUnsignedLongRegister(string name, ulong val)
{
var remoteValue = new RemoteValueFake(name, val.ToString());
remoteValue.SetTypeInfo(new SbTypeStub("unsigned long", TypeFlags.IS_INTEGER));
remoteValue.SetValueType(DebuggerApi.ValueType.Register);
return(remoteValue);
}
public static RemoteValueFake CreateSimpleBool(string name, bool val)
{
var remoteValue = new RemoteValueFake(name, val ? "true" : "false");
var type = new SbTypeStub("bool", TypeFlags.IS_SCALAR);
type.SetByteSize(sizeof(bool));
remoteValue.SetTypeInfo(type);
return(remoteValue);
}
public void CreateValueFromExpressionWhenExpressionNotFound()
{
var value = new RemoteValueFake("_myVar", "17");
var exprValue = value.CreateValueFromExpression("name", "dummyExpression");
Assert.That(exprValue.GetName(), Is.EqualTo(""));
Assert.That(exprValue.GetDefaultValue(), Is.EqualTo(""));
Assert.That(exprValue.GetError().Fail, Is.True);
}
public static RemoteValueFake CreateSimpleDouble(string name, double val)
{
var remoteValue = new RemoteValueFake(name, val.ToString());
var type = new SbTypeStub("double", TypeFlags.IS_FLOAT);
type.SetByteSize(sizeof(double));
remoteValue.SetTypeInfo(type);
return(remoteValue);
}
public void CantAddChildMoreThanOnce()
{
var value = new RemoteValueFake("_myVar", "17");
var child = new RemoteValueFake("_myChild", "23");
value.AddChild(child);
Assert.Throws <InvalidOperationException>(() => value.AddChild(child));
}
public static RemoteValueFake CreateSimpleLong(string name, long val)
{
var remoteValue = new RemoteValueFake(name, val.ToString());
var type = new SbTypeStub("long", TypeFlags.IS_INTEGER);
type.SetByteSize(sizeof(long));
remoteValue.SetTypeInfo(type);
return(remoteValue);
}
public static RemoteValueFake CreateLldbEvalError(LldbEvalErrorCode errCode,
string errorMessage = "",
string name = "", string value = "")
{
var errorValue = new RemoteValueFake(name, value);
errorValue.SetError(new SbErrorStub(false, errorMessage, Convert.ToUInt32(errCode)));
return(errorValue);
}
public static RemoteValueFake CreateUnsafeAddressPointer(
string typeName, string name, string value)
{
var remoteValue = new RemoteValueFake(name, value);
var typeFlags = TypeFlags.IS_POINTER;
remoteValue.SetTypeInfo(new SbTypeStub(typeName, typeFlags));
return(remoteValue);
}
public static RemoteValueFake CreateSimpleChar(string name, char val)
{
var remoteValue = new RemoteValueFake(name, val.ToString());
var type = new SbTypeStub("char", TypeFlags.IS_SCALAR);
type.SetByteSize(sizeof(char));
remoteValue.SetTypeInfo(type);
return(remoteValue);
}
public void GetChildrenWhenOutOfBounds()
{
var value = new RemoteValueFake("_myVar", "17");
value.AddChild(new RemoteValueFake("child", "pi/e"));
List <RemoteValue> children = value.GetChildren(0, 3);
Assert.That(children[0].GetDefaultValue(), Is.EqualTo("pi/e"));
Assert.That(children[1], Is.Null);
}
public static RemoteValueFake CreateReference(string typeName, string name, string value)
{
if (!IsHex(value))
{
throw new Exception("Reference RemoteValueFake requires value to be a hex value");
}
var remoteValue = new RemoteValueFake(name, value);
remoteValue.SetTypeInfo(new SbTypeStub(typeName, TypeFlags.IS_REFERENCE));
return(remoteValue);
}
public static RemoteValueFake CreateSimpleArray <T>(string name, string typeName,
Func <string, T, RemoteValueFake> itemFactory, params T[] values)
{
var remoteValue = new RemoteValueFake(name, "");
remoteValue.SetTypeInfo(new SbTypeStub($"{typeName}[]", TypeFlags.IS_ARRAY));
for (int i = 0; i < values.Length; i++)
{
remoteValue.AddChild(itemFactory($"[{i}]", values[i]));
}
return(remoteValue);
}
public static RemoteValueFake CreateAddressOf(RemoteValueFake remoteValue, long address)
{
var sbAddress = new RemoteValueFake(null, $"0x{address.ToString("X")}");
var type =
new SbTypeStub($"{remoteValue.GetTypeName()}*",
TypeFlags.HAS_CHILDREN | TypeFlags.IS_POINTER | TypeFlags.HAS_VALUE);
type.SetByteSize(PtrSize);
sbAddress.SetTypeInfo(type);
sbAddress.AddChild(remoteValue);
return(sbAddress);
}
public RemoteValue Dereference()
{
if (dereference != null)
{
return(dereference);
}
var remoteValueError = new RemoteValueFake("", "");
remoteValueError.SetError(new SbErrorStub(false,
"error: error: Not a pointer type or no child"));
return(remoteValueError);
}
public RemoteValue CreateValueFromAddress(string name, ulong address, SbType type)
{
if (valuesForAddress.TryGetValue(address, out RemoteValue value))
{
return(new RemoteValueNameDecorator(value, name));
}
var remoteValueError = new RemoteValueFake("", "");
remoteValueError.SetError(new SbErrorStub(false, "invalid"));
return(remoteValueError);
}
public void GetValueForExpressionChildDoesntExist()
{
var list = new RemoteValueFake("list", "");
list.SetTypeInfo(new SbTypeStub("CustomListType", TypeFlags.IS_CLASS));
list.AddChild(new RemoteValueFake("size", "17"));
Assert.False(list.TypeIsPointerType());
var value = list.GetValueForExpressionPath("list->end");
Assert.That(value.GetError().Fail());
}
public void GetValueForExpressionInvalidExpression([Values(".9", "size")] string path)
{
var list = new RemoteValueFake("list", "");
list.SetTypeInfo(new SbTypeStub("CustomListType", TypeFlags.IS_CLASS));
list.AddChild(new RemoteValueFake("size", "17"));
Assert.False(list.TypeIsPointerType());
var value = list.GetValueForExpressionPath(path);
Assert.That(value.GetError().Fail());
}
public void GetValueForExpressionPointerStructMismatch()
{
var list = new RemoteValueFake("list", "");
list.SetTypeInfo(
new SbTypeStub("CustomListType*", TypeFlags.IS_CLASS | TypeFlags.IS_POINTER));
list.AddChild(new RemoteValueFake("size", "17"));
Assert.True(list.TypeIsPointerType());
var value = list.GetValueForExpressionPath(".size");
Assert.That(value.GetError().Fail());
}
public static RemoteValueFake CreateClassReference(string className, string name,
string value)
{
if (!IsHex(value))
{
throw new Exception("Pointer RemoteValueFake requires value to be a hex value");
}
var remoteValue = new RemoteValueFake(name, value);
var classType = new SbTypeStub(className, TypeFlags.IS_CLASS);
var pointerType = new SbTypeStub(className + "&", TypeFlags.IS_REFERENCE, classType);
remoteValue.SetTypeInfo(pointerType);
return(remoteValue);
}
// Resolves expressions to values added via AddValueFromExpression().
// If there are multiple values added to the same expression it iterates them until we
// get to the last value, which is never discarded.
//
// Example:
// var box = new RemoteValueFake("myBox", "");
// box.AddValueFromExpression("expression", new RemoteValueFake("int", "1"));
// box.AddValueFromExpression("expression", new RemoteValueFake("int", "2"));
//
// var t = box.CreateValueFromExpression("temp1", "expression");
// var y = box.CreateValueFromExpression("temp2", "expression");
// var z = box.CreateValueFromExpression("temp3", "expression");
// Assert.That(t.GetDefaultValue(), Is.EqualTo("1"));
// Assert.That(y.GetDefaultValue(), Is.EqualTo("2"));
// Assert.That(z.GetDefaultValue(), Is.EqualTo("2"));
public RemoteValue CreateValueFromExpression(string name, string expression)
{
Queue <RemoteValue> values;
if (expressionValues.TryGetValue(expression, out values))
{
RemoteValue resultValue = values.Count > 1 ? values.Dequeue() : values.Peek();
return(new RemoteValueNameDecorator(resultValue, name));
}
var remoteValueError = new RemoteValueFake("", "");
remoteValueError.SetError(new SbErrorStub(false, "error: error: No value"));
return(remoteValueError);
}
public void CreateValueFromExpressionWhenExpressionFound()
{
var value = new RemoteValueFake("_myVar", "17");
var exprValue = new RemoteValueFake("$23", "Q");
exprValue.SetTypeInfo(new SbTypeStub("char", TypeFlags.IS_SCALAR));
value.AddValueFromExpression("dummyExpression", exprValue);
var exprResult = value.CreateValueFromExpression("exprName", "dummyExpression");
Assert.That(exprResult.GetName(), Is.EqualTo("exprName"));
Assert.That(exprResult.GetTypeName(), Is.EqualTo("char"));
Assert.That(exprResult.GetDefaultValue(), Is.EqualTo("Q"));
}
