public void TestSemaphore_RenderInParallel()
{
Mock <IBrowserWindowSizeProvider> sizeMock = new Mock <IBrowserWindowSizeProvider>(MockBehavior.Strict);
sizeMock.Setup(x => x.GetBrowserWindowSize()).ReturnsAsync(new BrowserWindowSize {
Width = 1920
});
Mock <IJSRuntime> _jsruntimeMock = new Mock <IJSRuntime>(MockBehavior.Strict);
_jsruntimeMock.Setup(x => x.InvokeAsync <IJSVoidResult>("mudResizeListenerFactory.listenForResize", It.IsAny <object[]>()))
.ReturnsAsync(Mock.Of <IJSVoidResult>(), TimeSpan.FromMilliseconds(200)).Verifiable();
_jsruntimeMock.Setup(x => x.InvokeAsync <IJSVoidResult>("mudResizeListenerFactory.cancelListeners", It.IsAny <object[]>()))
.ReturnsAsync(Mock.Of <IJSVoidResult>);
BreakpointService service = new BreakpointService(_jsruntimeMock.Object, sizeMock.Object);
Context.Services.AddSingleton <IBreakpointService, BreakpointService>(sp => service);
var comp = Context.RenderComponent <RenderMultipleHiddenInParallel>();
comp.WaitForAssertion(() => comp.FindAll(".xl").Should().HaveCount(10), TimeSpan.FromSeconds(1));
comp.WaitForAssertion(() => comp.FindAll(".lg-and-up").Should().HaveCount(10), TimeSpan.FromSeconds(1));
comp.WaitForAssertion(() => comp.FindAll(".md-and-up").Should().HaveCount(10), TimeSpan.FromSeconds(1));
comp.WaitForAssertion(() => comp.FindAll(".sm-and-up").Should().HaveCount(10), TimeSpan.FromSeconds(1));
}
public async Task Subscribe(BreakpointService service,
ResizeOptions options)
{
var result = await service.Subscribe((x) => ActualSize = x, options);
SubscriptionId = result.SubscriptionId;
}
public void SetUp()
{
_browserWindowSizeProvider = new Mock <IBrowserWindowSizeProvider>();
_browserWindowSizeProvider.Setup(x => x.GetBrowserWindowSize()).ReturnsAsync(new BrowserWindowSize {
Width = 970, Height = 30
}).Verifiable();
_jsruntimeMock = new Mock <IJSRuntime>();
_service = new BreakpointService(_jsruntimeMock.Object, _browserWindowSizeProvider.Object);
}
public InitializeHandler(
ILoggerFactory factory,
DebugService debugService,
BreakpointService breakpointService)
{
_logger = factory.CreateLogger <InitializeHandler>();
_debugService = debugService;
_breakpointService = breakpointService;
}
public async Task Subscribe_WithOptionsSetInConstructor()
{
var customResizeOptioons = new ResizeOptions
{
ReportRate = 120,
};
var optionGetter = new Mock <IOptions <ResizeOptions> >();
optionGetter.SetupGet(x => x.Value).Returns(customResizeOptioons);
_service = new BreakpointService(_jsruntimeMock.Object, _browserWindowSizeProvider.Object, optionGetter.Object);
await CheckSubscriptionOptions(customResizeOptioons, true);
}
public AttachHandler(
ILoggerFactory factory,
IJsonRpcServer jsonRpcServer,
DebugService debugService,
PowerShellContextService powerShellContextService,
DebugStateService debugStateService,
BreakpointService breakpointService,
DebugEventHandlerService debugEventHandlerService)
{
_logger = factory.CreateLogger <AttachHandler>();
_jsonRpcServer = jsonRpcServer;
_debugService = debugService;
_breakpointService = breakpointService;
_powerShellContextService = powerShellContextService;
_debugStateService = debugStateService;
_debugEventHandlerService = debugEventHandlerService;
}
public DisassemblyViewModel(
StoryService storyService,
DebuggerService debuggerService,
BreakpointService breakpointService,
// TODO: I haven't found a better way of enforcing this to be filled in time yet
LabelService labelService,
RoutineService routineService,
NavigationService navigationService,
EditRoutineNameDialogViewModel editRoutineNameDialogViewModel)
: base("DisassemblyView")
{
this.storyService = storyService;
this.debuggerService = debuggerService;
this.debuggerService.MachineCreated += DebuggerService_MachineCreated;
this.debuggerService.MachineDestroyed += DebuggerService_MachineDestroyed;
this.debuggerService.StateChanged += DebuggerService_StateChanged;
this.debuggerService.Stepped += DebuggerService_Stepped;
this.breakpointService = breakpointService;
this.breakpointService.Added += BreakpointService_Added;
this.breakpointService.Removed += BreakpointService_Removed;
this.routineService = routineService;
this.routineService.RoutineNameChanged += RoutineService_RoutineNameChanged;
this.navigationService = navigationService;
this.navigationService.NavigationRequested += NavigationService_NavigationRequested;
this.editRoutineNameDialogViewModel = editRoutineNameDialogViewModel;
lines = new BulkObservableCollection <DisassemblyLineViewModel>();
addressToLineMap = new IntegerMap <DisassemblyLineViewModel>();
routineAddressAndIndexList = new List <AddressAndIndex>();
stackLines = new List <DisassemblyLineViewModel>();
this.EditNameCommand = RegisterCommand <int>(
text: "EditName",
name: "Edit Name",
executed: EditNameExecuted,
canExecute: CanEditNameExecute);
}
public LaunchAndAttachHandler(
ILoggerFactory factory,
IDebugAdapterServerFacade debugAdapterServer,
BreakpointService breakpointService,
DebugEventHandlerService debugEventHandlerService,
DebugService debugService,
DebugStateService debugStateService,
PowerShellContextService powerShellContextService,
RemoteFileManagerService remoteFileManagerService)
{
_logger = factory.CreateLogger <LaunchAndAttachHandler>();
_debugAdapterServer = debugAdapterServer;
_breakpointService = breakpointService;
_debugEventHandlerService = debugEventHandlerService;
_debugService = debugService;
_debugStateService = debugStateService;
_debugStateService.ServerStarted = new TaskCompletionSource <bool>();
_powerShellContextService = powerShellContextService;
_remoteFileManagerService = remoteFileManagerService;
}
/// <summary>
/// Start the debug server listening.
/// </summary>
/// <returns>A task that completes when the server is ready.</returns>
public async Task StartAsync()
{
_debugAdapterServer = await DebugAdapterServer.From(options =>
{
// We need to let the PowerShell Context Service know that we are in a debug session
// so that it doesn't send the powerShell/startDebugger message.
_psesHost = ServiceProvider.GetService <PsesInternalHost>();
_psesHost.DebugContext.IsDebugServerActive = true;
options
.WithInput(_inputStream)
.WithOutput(_outputStream)
.WithServices(serviceCollection =>
serviceCollection
.AddLogging()
.AddOptions()
.AddPsesDebugServices(ServiceProvider, this))
// TODO: Consider replacing all WithHandler with AddSingleton
.WithHandler <LaunchAndAttachHandler>()
.WithHandler <DisconnectHandler>()
.WithHandler <BreakpointHandlers>()
.WithHandler <ConfigurationDoneHandler>()
.WithHandler <ThreadsHandler>()
.WithHandler <StackTraceHandler>()
.WithHandler <ScopesHandler>()
.WithHandler <VariablesHandler>()
.WithHandler <ContinueHandler>()
.WithHandler <NextHandler>()
.WithHandler <PauseHandler>()
.WithHandler <StepInHandler>()
.WithHandler <StepOutHandler>()
.WithHandler <SourceHandler>()
.WithHandler <SetVariableHandler>()
.WithHandler <DebugEvaluateHandler>()
// The OnInitialize delegate gets run when we first receive the _Initialize_ request:
// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
.OnInitialize(async(server, request, cancellationToken) =>
{
// We need to make sure the host has been started
_startedPses = !await _psesHost.TryStartAsync(new HostStartOptions(), CancellationToken.None).ConfigureAwait(false);
// Ensure the debugger mode is set correctly - this is required for remote debugging to work
_psesHost.DebugContext.EnableDebugMode();
BreakpointService breakpointService = server.GetService <BreakpointService>();
// Clear any existing breakpoints before proceeding
await breakpointService.RemoveAllBreakpointsAsync().ConfigureAwait(false);
})
// The OnInitialized delegate gets run right before the server responds to the _Initialize_ request:
// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
.OnInitialized((server, request, response, cancellationToken) =>
{
response.SupportsConditionalBreakpoints = true;
response.SupportsConfigurationDoneRequest = true;
response.SupportsFunctionBreakpoints = true;
response.SupportsHitConditionalBreakpoints = true;
response.SupportsLogPoints = true;
response.SupportsSetVariable = true;
return(Task.CompletedTask);
});
}).ConfigureAwait(false);
}
