public void SetUp()
{
mockFrame = Substitute.For <RemoteFrame>();
var childAdapterFactory = new RemoteValueChildAdapter.Factory();
var varInfoFactory = new LLDBVariableInformationFactory(childAdapterFactory);
var varInfoBuilder = new VarInfoBuilder(varInfoFactory);
varInfoFactory.SetVarInfoBuilder(varInfoBuilder);
var registerSetsBuilderFactory = new RegisterSetsBuilder.Factory(varInfoFactory);
registerSetsBuilder = registerSetsBuilderFactory.Create(mockFrame);
generalPurposeRegisters = Substitute.For <RemoteValue>();
generalPurposeRegisters.GetName().Returns("General Purpose Registers");
generalPurposeRegisters.GetNumChildren().Returns(0u);
floatingPointRegisters = Substitute.For <RemoteValue>();
floatingPointRegisters.GetName().Returns("Floating Point Registers");
floatingPointRegisters.GetNumChildren().Returns(3u);
xmm0 = Substitute.For <RemoteValue>();
xmm0.GetName().Returns("xmm0");
xmm8 = Substitute.For <RemoteValue>();
xmm8.GetName().Returns("xmm8");
other = Substitute.For <RemoteValue>();
other.GetName().Returns("other");
floatingPointRegisters.GetChildren(0, 3).Returns(
new List <RemoteValue>()
{
xmm0, xmm8, other
});
}
protected BaseDebugStackFrame(DebugDocumentContext.Factory debugDocumentContextFactory,
IChildrenProviderFactory childrenProviderFactory,
DebugCodeContext.Factory debugCodeContextFactory,
CreateDebugExpressionDelegate createExpressionDelegate,
IVariableInformationFactory varInfoFactory,
IVariableInformationEnumFactory varInfoEnumFactory,
AD7FrameInfoCreator ad7FrameInfoCreator,
IRegisterSetsBuilder registerSetsBuilder,
IDebugEngineHandler debugEngineHandler, RemoteFrame frame,
IDebugThread2 thread, IGgpDebugProgram debugProgram,
ITaskExecutor taskExecutor)
{
this.debugDocumentContextFactory = debugDocumentContextFactory;
this._childrenProviderFactory = childrenProviderFactory;
this.debugCodeContextFactory = debugCodeContextFactory;
this.createExpressionDelegate = createExpressionDelegate;
this.varInfoFactory = varInfoFactory;
this.varInfoEnumFactory = varInfoEnumFactory;
this.ad7FrameInfoCreator = ad7FrameInfoCreator;
this.registerSetsBuilder = registerSetsBuilder;
this.debugEngineHandler = debugEngineHandler;
this.debugProgram = debugProgram;
lldbFrame = frame;
this.thread = thread;
this._taskExecutor = taskExecutor;
documentContext = new Lazy <IDebugDocumentContext2>(() => CreateDocumentContext());
codeContext = new Lazy <IDebugCodeContext2>(() => CreateCodeContext());
}
public FrameVariablesProvider(
IRegisterSetsBuilder registerSetsBuilder,
RemoteFrame lldbFrame,
IVariableInformationFactory varInfoFactory)
{
_registerSetsBuilder = registerSetsBuilder;
_lldbFrame = lldbFrame;
_varInfoFactory = varInfoFactory;
}
public virtual IDebugStackFrame Create(AD7FrameInfoCreator ad7FrameInfoCreator,
RemoteFrame frame, IDebugThread thread,
IDebugEngineHandler debugEngineHandler,
IGgpDebugProgram debugProgram) =>
new DebugStackFrame(debugDocumentContextFactory, childrenProviderFactory,
debugCodeContextFactory, createExpressionDelegate,
varInfoFactory, varInfoEnumFactory, ad7FrameInfoCreator,
registerSetsBuilderFactory.Create(frame), debugEngineHandler,
frame, thread, debugProgram, taskExecutor);
public virtual IDebugAsyncExpression Create(RemoteFrame frame, string text,
IDebugEngineHandler debugEngineHandler, IGgpDebugProgram debugProgram,
IDebugThread2 thread)
{
IAsyncExpressionEvaluator evaluator = asyncEvaluatorFactory.Create(frame, text);
return(new DebugAsyncExpression(debugEngineHandler, evaluator, taskExecutor,
debugProgram, thread));
}
GrpcSbFrame CreateGrpcSbFrame(RemoteFrame frame)
=> frame == null ? null : new GrpcSbFrame
{
Id = frameStore.AddObject(frame),
FunctionName = frame.GetFunctionName() ?? "",
FunctionNameWithSignature = frame.GetFunctionNameWithSignature() ?? "",
ProgramCounter = frame.GetPC(),
LineEntry = GrpcFactoryUtils.CreateGrpcLineEntryInfo(frame.GetLineEntry())
};
public void SetUp()
{
_mockRemoteFrame = Substitute.For <RemoteFrame>();
var childAdapterFactory = new RemoteValueChildAdapter.Factory();
_varInfoFactory = new LLDBVariableInformationFactory(childAdapterFactory);
_registerSetsBuilder = new RegisterSetsBuilder.Factory(_varInfoFactory)
.Create(_mockRemoteFrame);
_frameVariablesProvider = new FrameVariablesProvider(_registerSetsBuilder,
_mockRemoteFrame, _varInfoFactory);
SetupAllVariables();
}
public override Task <GetRegistersResponse> GetRegisters(GetRegistersRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
List <RemoteValue> registers = frame.GetRegisters();
var response = new GetRegistersResponse();
response.Registers.Add(
registers.Select(s => GrpcFactoryUtils.CreateValue(
s, valueStore.AddObject(s))).ToList());
return(Task.FromResult(response));
}
public virtual IAsyncExpressionEvaluator Create(RemoteFrame frame, string text)
{
// Get preferred expression evaluation option. This is performed here to
// pick up configuration changes in runtime (e.g. the user can enable and
// disable lldb-eval during a single debug session).
var expressionEvaluationStrategy = _extensionOptions.ExpressionEvaluationStrategy;
return(new AsyncExpressionEvaluator(frame, text, _vsExpressionCreator,
_varInfoBuilder, _createPropertyDelegate,
_errorDebugPropertyFactory,
_debugEngineCommands,
expressionEvaluationStrategy,
_expressionEvaluationRecorder, _timeSource));
}
public override Task <GetInfoResponse> GetInfo(GetInfoRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
FrameInfo <SbModule> info = frame.GetInfo((FrameInfoFlags)request.Fields);
// Note: info can't be null since it's a struct.
var moduleId = info.Module != null?moduleStore.AddObject(info.Module) : (long?)null;
return(Task.FromResult(new GetInfoResponse
{
Info = GrpcFactoryUtils.CreateFrameInfo(info, moduleId)
}));
}
public void GetInfoTypesForMethod()
{
RemoteFrame methodStackFrame = CreateMethodStackFrame();
var fields = FrameInfoFlags.FIF_FUNCNAME |
FrameInfoFlags.FIF_FUNCNAME_ARGS |
FrameInfoFlags.FIF_FUNCNAME_ARGS_TYPES;
var info = methodStackFrame.GetInfo(fields);
Assert.AreEqual(FrameInfoFlags.FIF_FUNCNAME,
info.ValidFields & FrameInfoFlags.FIF_FUNCNAME);
Assert.AreEqual(string.Format("{0}({1}, {2})", NAME, ARG1_TYPE_NAME, ARG2_TYPE_NAME),
info.FuncName);
}
public override Task <EvaluateExpressionLldbEvalResponse> EvaluateExpressionLldbEval(
EvaluateExpressionLldbEvalRequest request, ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
RemoteValue value = frame.EvaluateExpressionLldbEval(request.Expression);
var response = new EvaluateExpressionLldbEvalResponse();
if (value != null)
{
response.Value = GrpcFactoryUtils.CreateValue(value, valueStore.AddObject(value));
}
return(Task.FromResult(response));
}
public override Task <GetValueForVariablePathResponse> GetValueForVariablePath(
GetValueForVariablePathRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
RemoteValue value = frame.GetValueForVariablePath(request.VariablePath);
var response = new GetValueForVariablePathResponse();
if (value != null)
{
response.Value = GrpcFactoryUtils.CreateValue(value, valueStore.AddObject(value));
}
return(Task.FromResult(response));
}
public override Task <GetVariablesResponse> GetVariables(GetVariablesRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
List <RemoteValue> variables =
frame.GetVariables(
request.Arguments, request.Locals, request.Statics, request.OnlyInScope);
var response = new GetVariablesResponse();
response.Variables.Add(
variables.Select(s => GrpcFactoryUtils.CreateValue(
s, valueStore.AddObject(s))).ToList());
return(Task.FromResult(response));
}
public override Task <GetSymbolResponse> GetSymbol(GetSymbolRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
SbSymbol symbol = frame.GetSymbol();
var response = new GetSymbolResponse();
if (symbol != null)
{
response.Symbol = new GrpcSbSymbol {
Id = symbolStore.AddObject(symbol)
};
}
return(Task.FromResult(response));
}
public override Task <GetFunctionResponse> GetFunction(GetFunctionRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
SbFunction function = frame.GetFunction();
var response = new GetFunctionResponse();
if (function != null)
{
response.Function = new GrpcSbFunction {
Id = functionStore.AddObject(function)
};
}
return(Task.FromResult(response));
}
public override Task <GetModuleResponse> GetModule(GetModuleRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
SbModule module = frame.GetModule();
GetModuleResponse response = new GetModuleResponse();
if (module != null)
{
response.Module = new GrpcSbModule {
Id = moduleStore.AddObject(module)
};
}
return(Task.FromResult(response));
}
public override Task <GetThreadResponse> GetThread(GetThreadRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
RemoteThread thread = frame.GetThread();
var response = new GetThreadResponse();
if (thread != null)
{
response.Thread = new GrpcSbThread()
{
Id = threadStore.AddObject(thread)
};
}
return(Task.FromResult(response));
}
public void SetUp()
{
_mockDebuggerStackFrame = Substitute.For <RemoteFrame>();
var childAdapterFactory = new RemoteValueChildAdapter.Factory();
var varInfoFactory = new LLDBVariableInformationFactory(childAdapterFactory);
_vsExpressionCreator = new VsExpressionCreator();
_metrics = Substitute.For <IMetrics>();
var eventScheduler = new EventSchedulerFake();
var eventSchedulerFactory = Substitute.For <IEventSchedulerFactory>();
eventSchedulerFactory.Create(Arg.Do <System.Action>(a => eventScheduler.Callback = a))
.Returns(eventScheduler);
var timer = new TimerFake();
const int minimumBatchSeparationMilliseconds = 1;
var batchEventAggregator =
new BatchEventAggregator <ExpressionEvaluationBatch, ExpressionEvaluationBatchParams,
ExpressionEvaluationBatchSummary>(minimumBatchSeparationMilliseconds,
eventSchedulerFactory, timer);
_expressionEvaluationRecorder =
new ExpressionEvaluationRecorder(batchEventAggregator, _metrics);
_timeSource = new MonotonicTimeSource();
_taskExecutor = Substitute.ForPartsOf <FakeTaskExecutor>();
var enumFactory = new VariableInformationEnum.Factory(_taskExecutor);
var childrenProviderFactory = new ChildrenProvider.Factory();
var debugPropertyFactory = new DebugProperty.Factory(
enumFactory, childrenProviderFactory, null, _vsExpressionCreator, _taskExecutor);
_createPropertyDelegate = debugPropertyFactory.Create;
childrenProviderFactory.Initialize(_createPropertyDelegate);
_varInfoBuilder = new VarInfoBuilder(varInfoFactory);
varInfoFactory.SetVarInfoBuilder(_varInfoBuilder);
_engineCommandsMock = Substitute.For <IDebugEngineCommands>();
_mockDebugEngineHandler = Substitute.For <IDebugEngineHandler>();
_mockProgram = Substitute.For <IGgpDebugProgram>();
_mockThread = Substitute.For <IDebugThread2>();
}
public override Task <FindValueResponse> FindValue(FindValueRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
RemoteValue variable = frame.FindValue(request.VariableName,
request.ValueType.ConvertTo <LldbApi.ValueType>());
var response = new FindValueResponse();
if (variable != null)
{
response.Variable = GrpcFactoryUtils.CreateValue(
variable, valueStore.AddObject(variable));
}
return(Task.FromResult(response));
}
public void SetUp()
{
lineEntry = new LineEntryInfo();
mockDocumentContext = Substitute.For <IDebugDocumentContext2>();
mockThread = Substitute.For <IDebugThread>();
mockDocumentContextFactory = Substitute.For <DebugDocumentContext.Factory>();
mockDocumentContextFactory.Create(lineEntry).Returns(mockDocumentContext);
mockDebuggerStackFrame = Substitute.For <RemoteFrame>();
mockDebuggerStackFrame.GetLineEntry().Returns(lineEntry);
mockDebuggerStackFrame.GetPC().Returns(TEST_PC);
mockDebuggerStackFrame.GetFunctionName().Returns(NAME);
mockDebuggerStackFrame.GetFunctionNameWithSignature().Returns(NAME);
mockCodeContextFactory = Substitute.For <DebugCodeContext.Factory>();
mockExpressionFactory = Substitute.For <DebugExpression.Factory>();
mockModuleCache = Substitute.For <IDebugModuleCache>();
mockDebugEngineHandler = Substitute.For <IDebugEngineHandler>();
mockProgram = Substitute.For <IGgpDebugProgram>();
taskExecutor = new TaskExecutor(new JoinableTaskContext().Factory);
var childAdapterFactory = new RemoteValueChildAdapter.Factory();
var varInfoFactory = new LLDBVariableInformationFactory(childAdapterFactory);
var varInfoEnumFactory = new VariableInformationEnum.Factory(taskExecutor);
var childrenProviderFactory = new ChildrenProvider.Factory();
var propertyFactory =
new DebugProperty.Factory(varInfoEnumFactory, childrenProviderFactory,
Substitute.For <DebugCodeContext.Factory>(),
new VsExpressionCreator(), taskExecutor);
childrenProviderFactory.Initialize(propertyFactory.Create);
var registerSetsBuilderFactory = new RegisterSetsBuilder.Factory(varInfoFactory);
stackFrame = new DebugStackFrame.Factory(mockDocumentContextFactory,
childrenProviderFactory, mockCodeContextFactory, mockExpressionFactory.Create,
varInfoFactory, varInfoEnumFactory, registerSetsBuilderFactory, taskExecutor)
.Create(new AD7FrameInfoCreator(mockModuleCache), mockDebuggerStackFrame,
mockThread, mockDebugEngineHandler, mockProgram);
stackFrameAsync = new DebugStackFrameAsync.Factory(mockDocumentContextFactory,
childrenProviderFactory, mockCodeContextFactory, mockExpressionFactory.Create,
varInfoFactory, varInfoEnumFactory, registerSetsBuilderFactory, taskExecutor)
.Create(new AD7FrameInfoCreator(mockModuleCache), mockDebuggerStackFrame,
mockThread, mockDebugEngineHandler, mockProgram);
}
public override Task <GetPhysicalStackRangeResponse> GetPhysicalStackRange(
GetPhysicalStackRangeRequest request, ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
AddressRange addressRange = frame.GetPhysicalStackRange();
var response = new GetPhysicalStackRangeResponse();
if (addressRange != null)
{
response.AddressRange = new GrpcAddressRange()
{
AddressMin = addressRange.addressMin,
AddressMax = addressRange.addressMax
};
}
return(Task.FromResult(response));
}
public void SetUp()
{
mockTarget = Substitute.For <SbTarget>();
mockDebuggerStackFrame = CreateMockStackFrame();
var mockArgument1 = Substitute.For <SbValue>();
mockArgument1.GetValue().Returns(ARG1_VALUE);
var mockArgument2 = Substitute.For <SbValue>();
mockArgument2.GetValue().Returns(ARG2_VALUE);
var functionArguments = new List <SbValue>();
functionArguments.Add(mockArgument1);
functionArguments.Add(mockArgument2);
mockDebuggerStackFrame.GetVariables(true, false, false, false).Returns(
functionArguments);
mockDebuggerStackFrame.GetFunction().GetArgumentName(0).Returns(ARG1_NAME);
mockDebuggerStackFrame.GetFunction().GetArgumentName(1).Returns(ARG2_NAME);
var mockArgTypeList = Substitute.For <SbTypeList>();
mockArgTypeList.GetSize().Returns(2u);
mockArgTypeList.GetTypeAtIndex(0u).GetName().Returns(ARG1_TYPE_NAME);
mockArgTypeList.GetTypeAtIndex(1u).GetName().Returns(ARG2_TYPE_NAME);
var mockFunctionType = Substitute.For <SbType>();
mockFunctionType.GetFunctionArgumentTypes().Returns(mockArgTypeList);
mockDebuggerStackFrame.GetFunction().GetType().Returns(mockFunctionType);
var optionsFactory = Substitute.For <ILldbExpressionOptionsFactory>();
var valueFactory = new RemoteValueImpl.Factory(optionsFactory);
stackFrame = new RemoteFrameImpl.Factory(valueFactory, optionsFactory)
.Create(mockDebuggerStackFrame);
}
DebugStackFrameAsync(DebugDocumentContext.Factory debugDocumentContextFactory,
IChildrenProviderFactory childrenProviderFactory,
DebugCodeContext.Factory debugCodeContextFactory,
CreateDebugExpressionDelegate createExpressionDelegate,
IVariableInformationFactory varInfoFactory,
IVariableInformationEnumFactory varInfoEnumFactory,
AD7FrameInfoCreator ad7FrameInfoCreator,
IRegisterSetsBuilder registerSetsBuilder,
IDebugEngineHandler debugEngineHandler, RemoteFrame frame,
IDebugThread2 thread, IGgpDebugProgram debugProgram,
ITaskExecutor taskExecutor) : base(debugDocumentContextFactory,
childrenProviderFactory,
debugCodeContextFactory,
createExpressionDelegate,
varInfoFactory, varInfoEnumFactory,
ad7FrameInfoCreator,
registerSetsBuilder,
debugEngineHandler, frame, thread,
debugProgram, taskExecutor)
{
}
AsyncExpressionEvaluator(RemoteFrame frame, string text,
VsExpressionCreator vsExpressionCreator,
VarInfoBuilder varInfoBuilder,
CreateDebugPropertyDelegate createPropertyDelegate,
ErrorDebugProperty.Factory errorDebugPropertyFactory,
IDebugEngineCommands debugEngineCommands,
ExpressionEvaluationStrategy expressionEvaluationStrategy,
ExpressionEvaluationRecorder expressionEvaluationRecorder,
ITimeSource timeSource)
{
_frame = frame;
_text = text;
_vsExpressionCreator = vsExpressionCreator;
_varInfoBuilder = varInfoBuilder;
_createPropertyDelegate = createPropertyDelegate;
_errorDebugPropertyFactory = errorDebugPropertyFactory;
_debugEngineCommands = debugEngineCommands;
_expressionEvaluationStrategy = expressionEvaluationStrategy;
_expressionEvaluationRecorder = expressionEvaluationRecorder;
_timeSource = timeSource;
}
IDebugStackFrame CreateStackFrame(RemoteFrame frame, IDebugThread thread,
IGgpDebugProgram debugProgram)
{
return(Substitute.For <IDebugStackFrame>());
}
private RegisterSetsBuilder(IVariableInformationFactory varInfoFactory, RemoteFrame frame)
{
this.varInfoFactory = varInfoFactory;
this.frame = frame;
}
public FrameInfoPair(RemoteFrame frame, FrameInfo <SbModule> info)
{
this.Frame = frame;
this.Info = info;
}
public virtual IRegisterSetsBuilder Create(RemoteFrame frame) => new RegisterSetsBuilder(varInfoFactory, frame);
public virtual IDebugExpression Create(RemoteFrame frame, string text,
IDebugEngineHandler debugEngineHandler,
IGgpDebugProgram debugProgram, IDebugThread2 thread)
=> new DebugExpression(debugEngineHandler,
asyncEvaluatorFactory.Create(frame, text), taskExecutor,
debugProgram, thread);
