public void GetAllInheritedTypesListCloserBaseClassesFirst() { // Class hierarchy: // // 111 211 121 221 // \ / \ / // 011 021 // \ / // 001 var type_001 = new SbTypeStub("type_001", TypeFlags.NONE); var type_011 = new SbTypeStub("type_011", TypeFlags.NONE); var type_021 = new SbTypeStub("type_021", TypeFlags.NONE); var type_111 = new SbTypeStub("type_111", TypeFlags.NONE); var type_211 = new SbTypeStub("type_211", TypeFlags.NONE); var type_121 = new SbTypeStub("type_121", TypeFlags.NONE); var type_221 = new SbTypeStub("type_221", TypeFlags.NONE); type_001.AddDirectBaseClass(type_011); type_001.AddDirectBaseClass(type_021); type_011.AddDirectBaseClass(type_111); type_011.AddDirectBaseClass(type_211); type_021.AddDirectBaseClass(type_121); type_021.AddDirectBaseClass(type_221); var remoteValue = new RemoteValueFake("leafVar", "leafValue"); remoteValue.SetTypeInfo(type_001); var varInfo = CreateVarInfo(remoteValue, "dummyDisplayName"); var inheritedTypes = varInfo.GetAllInheritedTypes().ToList(); Func <string, int> indexOf = typeName => inheritedTypes.IndexOf(typeName); Assert.That(inheritedTypes.Count, Is.EqualTo(7)); Assert.That(indexOf("type_111"), Is.GreaterThan(indexOf("type_011"))); Assert.That(indexOf("type_111"), Is.GreaterThan(indexOf("type_021"))); Assert.That(indexOf("type_111"), Is.GreaterThan(indexOf("type_001"))); Assert.That(indexOf("type_211"), Is.GreaterThan(indexOf("type_011"))); Assert.That(indexOf("type_211"), Is.GreaterThan(indexOf("type_021"))); Assert.That(indexOf("type_211"), Is.GreaterThan(indexOf("type_001"))); Assert.That(indexOf("type_121"), Is.GreaterThan(indexOf("type_011"))); Assert.That(indexOf("type_121"), Is.GreaterThan(indexOf("type_021"))); Assert.That(indexOf("type_121"), Is.GreaterThan(indexOf("type_001"))); Assert.That(indexOf("type_221"), Is.GreaterThan(indexOf("type_011"))); Assert.That(indexOf("type_221"), Is.GreaterThan(indexOf("type_021"))); Assert.That(indexOf("type_221"), Is.GreaterThan(indexOf("type_001"))); Assert.That(indexOf("type_011"), Is.GreaterThan(indexOf("type_001"))); Assert.That(indexOf("type_021"), Is.GreaterThan(indexOf("type_001"))); }
public async Task LldbEvalAsync() { const string expressionText = "myVar"; IDebugExpression expression = CreateExpression(expressionText, ExpressionEvaluationStrategy.LLDB_EVAL); RemoteValueFake expressionValueNode = RemoteValueFakeUtil.CreateClass("CustomType", "$17", "23"); _mockDebuggerStackFrame.EvaluateExpressionLldbEvalAsync(expressionText) .Returns(expressionValueNode); int status = expression.EvaluateAsync(0, null); var debugEventVerifier = Arg.Is <DebugExpressionEvaluationCompleteEvent>( e => expressionText.Equals(GetName(GetResult(e))) && "CustomType".Equals(GetType(GetResult(e))) && "23".Equals(GetValue(GetResult(e)))); // This assumes that task executor stub works synchronously. _mockDebugEngineHandler.Received().SendEvent( debugEventVerifier, Arg.Is(_mockProgram), Arg.Is(_mockThread)); await _taskExecutor.ReceivedWithAnyArgs(1).SubmitAsync( () => Task.CompletedTask, Arg.Any <CancellationToken>(), Arg.Any <string>(), Arg.Any <Type>()); Assert.AreEqual(VSConstants.S_OK, status); }
public void DeclareVariableWithErrorRemoteValue() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue"); remoteValue.AddValueFromExpression($"auto $test=5; $test", RemoteValueFakeUtil.CreateError("declaration error")); var natvisScope = new NatvisScope(); natvisScope.AddScopedName("test", "$test"); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); var exception = Assert.ThrowsAsync <ExpressionEvaluationFailed>( async() => await _evaluator.DeclareVariableAsync(varInfo, "test", "5", natvisScope)); Assert.That(exception.Message, Does.Contain("test")); Assert.That(exception.Message, Does.Contain("5")); Assert.That(exception.Message, Does.Contain("declaration error")); string logOutput = _nLogSpy.GetOutput(); Assert.That(logOutput, Does.Contain("test")); Assert.That(logOutput, Does.Contain("5")); Assert.That(logOutput, Does.Contain("declaration error")); }
public void FormatValue() { const string value = "test \t \n"; RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleString("tmp", value); Assert.That(format.FormatValue(remoteValue, ValueFormat.Default), Is.EqualTo(value)); }
public void EvaluateSyncWithFormatSpecifier() { string expressionText = "myVar"; string formatSpecifier = ",x"; string testText = expressionText + formatSpecifier; IDebugExpression expression = CreateExpression(testText); RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleInt("myVar", 16); _mockDebuggerStackFrame.FindValue(testText, ValueType.VariableGlobal) .Returns((RemoteValue)null); _mockDebuggerStackFrame.GetValueForVariablePath(expressionText) .Returns((RemoteValue)null); _mockDebuggerStackFrame.FindValue(expressionText, ValueType.VariableGlobal) .Returns((RemoteValue)null); _mockDebuggerStackFrame.EvaluateExpressionAsync(expressionText).Returns(remoteValue); Assert.AreEqual(VSConstants.S_OK, expression.EvaluateSync(0, 0, null, out IDebugProperty2 property)); Assert.AreEqual(testText, GetName(property)); Assert.AreEqual(testText, GetFullName(property)); Assert.AreEqual("int", GetType(property)); Assert.AreEqual("0x10", GetValue(property)); }
public async Task LldbEvalWithFallbackAsync(LldbEvalErrorCode lldbEvalErrorCode) { const string expressionText = "myVar"; IDebugExpression expression = CreateExpression( expressionText, ExpressionEvaluationStrategy.LLDB_EVAL_WITH_FALLBACK); RemoteValueFake errorValue = RemoteValueFakeUtil.CreateLldbEvalError(lldbEvalErrorCode); RemoteValueFake expressionValue = RemoteValueFakeUtil.CreateClass("CustomType", "$17", "23"); _mockDebuggerStackFrame.EvaluateExpressionLldbEvalAsync(expressionText) .Returns(errorValue); _mockDebuggerStackFrame.EvaluateExpressionAsync(expressionText) .Returns(expressionValue); Assert.AreEqual(VSConstants.S_OK, expression.EvaluateSync(0, 0, null, out IDebugProperty2 property)); Assert.AreEqual(expressionText, GetName(property)); Assert.AreEqual("CustomType", GetType(property)); Assert.AreEqual("23", GetValue(property)); // Make sure that a fallback to the LLDB happened. await _mockDebuggerStackFrame.Received(1).EvaluateExpressionLldbEvalAsync( Arg.Is(expressionText)); await _mockDebuggerStackFrame.Received(1).EvaluateExpressionAsync( Arg.Is(expressionText)); }
public async Task CloneContextVariablesAsync(string expr, string transformedExpr, string expectedValue) { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue"); RemoteValueFake exprResult = RemoteValueFakeUtil.CreateSimpleInt("x", 1); exprResult.SetClone(RemoteValueFakeUtil.CreateSimpleInt("y", 2)); remoteValue.AddValueFromExpression(transformedExpr, exprResult); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); var natvisScope = new NatvisScope(); natvisScope.AddScopedName("$i", "1U"); natvisScope.AddScopedName("var", "$var_0"); natvisScope.AddContextVariable("$var_0", exprResult); IVariableInformation result = await _evaluator.EvaluateExpressionAsync(expr, varInfo, natvisScope, "myVar"); Assert.That(await result.ValueAsync(), Is.EqualTo(expectedValue)); Assert.That(result.DisplayName, Is.EqualTo("myVar")); }
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 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 FormatStringView() { // Value has to be quoted, so that FormatStringView recognizes it as string. const string value = "\"test \\t \\n\""; const string unescapedValue = "test \t \n"; RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleString("tmp", value); Assert.That(format.FormatStringView(remoteValue, ValueFormat.Default), Is.EqualTo(unescapedValue)); }
public void TestGetExpressionValueBadExpression() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue"); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); Assert.That(async() => await _evaluator.EvaluateExpressionAsync( "test1", varInfo, new NatvisScope(), "result"), Throws.TypeOf <ExpressionEvaluationFailed>().With.Message.Contains("test1")); }
public void GetAllInheritedTypesWithNoBaseClass() { var remoteValue = new RemoteValueFake("dummyVar", "dummyValue"); remoteValue.SetTypeInfo(new SbTypeStub("MyType", TypeFlags.NONE)); var varInfo = CreateVarInfo(remoteValue, "dummyDisplayName"); var inheritedTypes = varInfo.GetAllInheritedTypes(); Assert.That(inheritedTypes, Is.EqualTo(new[] { "MyType" })); }
public void TestExpressionNameForReferenceOfVariable() { var remoteValue = new RemoteValueFake("$1", "0x0ddba11"); remoteValue.SetValueType(DebuggerApi.ValueType.ConstResult); remoteValue.SetTypeInfo(new SbTypeStub( "CustomType*", TypeFlags.HAS_CHILDREN | TypeFlags.HAS_VALUE | TypeFlags.IS_POINTER)); Assert.That(remoteValue.GetVariableAssignExpression(), Is.Null); }
public void GetValueForAssignmentNonRegister() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass( "customType", "var", "varValue"); remoteValue.SetValueType(ValueType.VariableLocal); remoteValue.SetSummary("varSummary"); Assert.That(format.GetValueForAssignment(remoteValue, ValueFormat.Default), Is.EqualTo("varValue")); }
public void FormatValueVectorRegister() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass( "unsigned char __attribute__((ext_vector_type(3)))", "xmm0", ""); remoteValue.SetValueType(ValueType.Register); remoteValue.SetSummary("(0x00, 0x01, 0x02)"); Assert.That(format.FormatValue(remoteValue, ValueFormat.Default), Is.EqualTo("{0x00, 0x01, 0x02}")); }
public void TestExpressionNameForInvalidValueType() { var remoteValue = new RemoteValueFake("myVar", "12358"); remoteValue.SetValueType(DebuggerApi.ValueType.Invalid); remoteValue.SetTypeInfo( new SbTypeStub("int", TypeFlags.HAS_VALUE | TypeFlags.IS_SCALAR)); remoteValue.SetAddressOf(RemoteValueFakeUtil.CreateSimpleLong("$0", 0xDEADBEEF)); Assert.That(remoteValue.GetVariableAssignExpression(), Is.Null); }
public void GetValueForExpressionPathFailure() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleArray( "test", "int", RemoteValueFakeUtil.CreateSimpleInt, 4); var varInfo = CreateVarInfo(remoteValue, "remoteValue"); var result = varInfo.GetValueForExpressionPath(new VsExpression("[1]", FormatSpecifier.EMPTY)); Assert.That(result.Error, Is.True); }
public void CanonicalBoolTypeValues(bool value) { var remoteValue = new RemoteValueFake("myVar", value ? "true" : "false"); var boolType = new SbTypeStub("MyBoolType", TypeFlags.IS_TYPEDEF); boolType.SetCanonicalType(new SbTypeStub("bool", TypeFlags.IS_SCALAR)); remoteValue.SetTypeInfo(boolType); var varInfo = varInfoBuilder.Create(remoteValue); Assert.That(varInfo.IsTruthy, Is.EqualTo(value)); }
public void GetAllInheritedTypesWhenTypeInfoIsNull() { var remoteValue = new RemoteValueFake("dummyVar", "dummyValue"); remoteValue.SetTypeInfo(null); var varInfo = CreateVarInfo(remoteValue, "dummyDisplayName"); var inheritedTypes = varInfo.GetAllInheritedTypes(); Assert.That(inheritedTypes, Is.Empty); }
public async Task IndexerAccessAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleIntArray("myArray", 3, 4, 5, 6); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync("[3]", varInfo, new NatvisScope(), null); Assert.That(exprVarInfo.DisplayName, Is.EqualTo("[3]")); Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("6")); }
public async Task Build_ClassValueAsync() { RemoteValueFake classValue = RemoteValueFakeUtil.CreateClass("C", "c", ""); classValue.AddChild(RemoteValueFakeUtil.CreateSimpleInt("f", 42)); classValue.AddChild(RemoteValueFakeUtil.CreateSimpleString("g", "\"s\"")); IVariableInformation varInfo = CreateVarInfo(classValue, "3"); string result = await ValueStringBuilder.BuildAsync(varInfo); Assert.That(result, Is.EqualTo("{f=42 g=\"s\"}")); }
public async Task GetValueForExpressionPathSuccessAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleArray( "test", "int", RemoteValueFakeUtil.CreateSimpleInt, 4, 7, 74, 47); var varInfo = CreateVarInfo(remoteValue, "remoteValue"); var result = varInfo.GetValueForExpressionPath(new VsExpression("[0]", FormatSpecifier.EMPTY)); Assert.That(result.Error, Is.False); Assert.That(await result.ValueAsync(), Is.EqualTo("4")); Assert.That(result.DisplayName, Is.EqualTo("[0]")); }
public void SetUp() { remoteValue = RemoteValueFakeUtil.CreateClass("int[]", "array", ""); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleString("child1", "value1")); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleString("child2", "value2")); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleString("child3", "value3")); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleString("child4", "value4")); var childAdapterFactory = new RemoteValueChildAdapter.Factory(); var varInfoFactory = new LLDBVariableInformationFactory(childAdapterFactory); varInfoBuilder = new VarInfoBuilder(varInfoFactory); varInfoFactory.SetVarInfoBuilder(varInfoBuilder); }
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 ClassMemberAccessAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", ""); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleBool("value1", true)); remoteValue.AddChild(RemoteValueFakeUtil.CreateSimpleInt("value2", 22)); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync( "value1", varInfo, new NatvisScope(), null); Assert.That(exprVarInfo.DisplayName, Is.EqualTo("value1")); Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("true")); }
public async Task EvaluateSimpleExpressionAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue"); remoteValue.AddValueFromExpression("14", RemoteValueFakeUtil.CreateSimpleInt("tmp", 14)); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); IVariableInformation result = await _evaluator.EvaluateExpressionAsync( "14", varInfo, new NatvisScope(), "myVar"); Assert.That(await result.ValueAsync(), Is.EqualTo("14")); Assert.That(result.DisplayName, Is.EqualTo("myVar")); }
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 GlobalExpressionAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateClass("MyType", "myType", "myValue"); remoteValue.AddValueFromExpression("test1", RemoteValueFakeUtil.CreateSimpleInt("dummy", 66)); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync( "test1", varInfo, new NatvisScope(), "result"); Assert.That(exprVarInfo.DisplayName, Is.EqualTo("result")); Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("66")); }
public async Task IndexerAccessWithTokenReplacementAsync() { RemoteValueFake remoteValue = RemoteValueFakeUtil.CreateSimpleIntArray("myArray", 3, 4, 5, 6); var natvisScope = new NatvisScope(); natvisScope.AddScopedName("$i", "2"); IVariableInformation varInfo = _varInfoFactory.Create(remoteValue); IVariableInformation exprVarInfo = await _evaluator.EvaluateExpressionAsync("[$i]", varInfo, natvisScope, null); Assert.That(exprVarInfo.DisplayName, Is.EqualTo("[2]")); Assert.That(await exprVarInfo.ValueAsync(), Is.EqualTo("5")); }
public async Task Build_ArrayLimitsOutputSizeAsync() { const int size = 100; _childValues = Enumerable.Range(0, size - 1).ToArray(); _remoteValue = RemoteValueFakeUtil.CreateSimpleIntArray("myArray", _childValues); IVariableInformation varInfo = CreateVarInfo(_remoteValue, size.ToString()); string result = await ValueStringBuilder.BuildAsync(varInfo); Assert.That( result, Is.EqualTo( "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20," + " 21, ...}")); }