/*******************************************************************************
* Copyright (c) 2012-2017 Codenvy, S.A.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Codenvy, S.A. - initial API and implementation
*******************************************************************************/
package org.eclipse.che.plugin.debugger.ide.debug;
import com.google.common.base.Optional;
import com.google.gwtmockito.GwtMockitoTestRunner;
import com.google.web.bindery.event.shared.EventBus;
import org.eclipse.che.api.core.jsonrpc.commons.RequestHandlerConfigurator;
import org.eclipse.che.api.core.jsonrpc.commons.RequestTransmitter;
import org.eclipse.che.api.core.jsonrpc.commons.reception.ConsumerConfiguratorOneToNone;
import org.eclipse.che.api.core.jsonrpc.commons.reception.ResultConfiguratorFromOne;
import org.eclipse.che.api.core.jsonrpc.commons.transmission.EndpointIdConfigurator;
import org.eclipse.che.api.core.jsonrpc.commons.transmission.MethodNameConfigurator;
import org.eclipse.che.api.core.jsonrpc.commons.transmission.ParamsConfigurator;
import org.eclipse.che.api.core.jsonrpc.commons.transmission.SendConfiguratorFromNone;
import org.eclipse.che.api.core.jsonrpc.commons.transmission.SendConfiguratorFromOne;
import org.eclipse.che.api.debug.shared.dto.BreakpointDto;
import org.eclipse.che.api.debug.shared.dto.DebugSessionDto;
import org.eclipse.che.api.debug.shared.dto.LocationDto;
import org.eclipse.che.api.debug.shared.dto.SimpleValueDto;
import org.eclipse.che.api.debug.shared.dto.StackFrameDumpDto;
import org.eclipse.che.api.debug.shared.dto.VariableDto;
import org.eclipse.che.api.debug.shared.dto.VariablePathDto;
import org.eclipse.che.api.debug.shared.dto.action.ResumeActionDto;
import org.eclipse.che.api.debug.shared.dto.action.StartActionDto;
import org.eclipse.che.api.debug.shared.dto.action.StepIntoActionDto;
import org.eclipse.che.api.debug.shared.dto.action.StepOutActionDto;
import org.eclipse.che.api.debug.shared.dto.action.StepOverActionDto;
import org.eclipse.che.api.debug.shared.model.DebuggerInfo;
import org.eclipse.che.api.debug.shared.model.Location;
import org.eclipse.che.api.debug.shared.model.SimpleValue;
import org.eclipse.che.api.debug.shared.model.StackFrameDump;
import org.eclipse.che.api.debug.shared.model.Variable;
import org.eclipse.che.api.debug.shared.model.VariablePath;
import org.eclipse.che.api.promises.client.Function;
import org.eclipse.che.api.promises.client.Operation;
import org.eclipse.che.api.promises.client.OperationException;
import org.eclipse.che.api.promises.client.Promise;
import org.eclipse.che.api.promises.client.PromiseError;
import org.eclipse.che.commons.annotation.Nullable;
import org.eclipse.che.ide.api.debug.Breakpoint;
import org.eclipse.che.ide.api.debug.BreakpointManager;
import org.eclipse.che.ide.api.debug.DebuggerServiceClient;
import org.eclipse.che.ide.api.filetypes.FileType;
import org.eclipse.che.ide.api.machine.events.WsAgentStateEvent;
import org.eclipse.che.ide.api.machine.events.WsAgentStateHandler;
import org.eclipse.che.ide.api.notification.NotificationManager;
import org.eclipse.che.ide.api.resources.Project;
import org.eclipse.che.ide.api.resources.Resource;
import org.eclipse.che.ide.api.resources.VirtualFile;
import org.eclipse.che.ide.debug.DebuggerDescriptor;
import org.eclipse.che.ide.debug.DebuggerManager;
import org.eclipse.che.ide.debug.DebuggerObserver;
import org.eclipse.che.ide.dto.DtoFactory;
import org.eclipse.che.ide.resource.Path;
import org.eclipse.che.ide.util.storage.LocalStorage;
import org.eclipse.che.ide.util.storage.LocalStorageProvider;
import org.eclipse.che.plugin.debugger.ide.BaseTest;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockSettings;
import org.mockito.MockitoAnnotations;
import org.mockito.internal.creation.MockSettingsImpl;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static junit.framework.TestCase.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Answers.RETURNS_DEEP_STUBS;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.RETURNS_SMART_NULLS;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Testing {@link AbstractDebugger} functionality.
*
* @author Artem Zatsarynnyi
* @author Valeriy Svydenko
* @author Dmytro Nochevnov
*/
@RunWith(GwtMockitoTestRunner.class)
public class DebuggerTest extends BaseTest {
private static final String DEBUG_INFO = "debug_info";
private static final String SESSION_ID = "debugger_id";
public static final int LINE_NUMBER = 20;
public static final String FQN = "org.test.Test";
public static final String PATH = "test/src/main/java/Test.java";
@Mock
private DebuggerServiceClient service;
@Mock
private DtoFactory dtoFactory;
@Mock
private LocalStorageProvider localStorageProvider;
@Mock
private EventBus eventBus;
@Mock
private ActiveFileHandler activeFileHandler;
@Mock
private DebuggerManager debuggerManager;
@Mock
private NotificationManager notificationManager;
@Mock
private BreakpointManager breakpointManager;
@Mock(answer = RETURNS_DEEP_STUBS)
private RequestTransmitter transmitter;
@Mock
private RequestHandlerConfigurator configurator;
@Mock
private Promise<Void> promiseVoid;
@Mock
private Promise<DebuggerInfo> promiseInfo;
@Mock
private PromiseError promiseError;
@Mock
private VirtualFile file;
@Mock
private LocalStorage localStorage;
@Mock
private DebuggerObserver observer;
@Mock
private LocationDto locationDto;
@Mock
private BreakpointDto breakpointDto;
@Mock
private Optional<Project> optional;
@Captor
private ArgumentCaptor<WsAgentStateHandler> extServerStateHandlerCaptor;
@Captor
private ArgumentCaptor<Operation<PromiseError>> operationPromiseErrorCaptor;
@Captor
private ArgumentCaptor<Operation<Void>> operationVoidCaptor;
@Captor
private ArgumentCaptor<Breakpoint> breakpointCaptor;
@Captor
private ArgumentCaptor<Function<DebugSessionDto, Void>> argumentCaptorFunctionJavaDebugSessionVoid;
@Captor
private ArgumentCaptor<Operation<DebuggerInfo>> argumentCaptorOperationJavaDebuggerInfo;
public final Breakpoint TEST_BREAKPOINT = new Breakpoint(Breakpoint.Type.BREAKPOINT, LINE_NUMBER, PATH, file, true);
public DebuggerDescriptor debuggerDescriptor;
private AbstractDebugger debugger;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
super.setUp();
debuggerDescriptor = new DebuggerDescriptor(NAME + " " + VERSION, HOST + ":" + PORT);
doReturn(locationDto).when(dtoFactory).createDto(LocationDto.class);
doReturn(breakpointDto).when(dtoFactory).createDto(BreakpointDto.class);
doReturn(locationDto).when(breakpointDto).getLocation();
doReturn(localStorage).when(localStorageProvider).get();
doReturn(DEBUG_INFO).when(localStorage).getItem(AbstractDebugger.LOCAL_STORAGE_DEBUGGER_SESSION_KEY);
doReturn(debugSessionDto).when(dtoFactory).createDtoFromJson(anyString(), eq(DebugSessionDto.class));
doReturn(Path.valueOf(PATH)).when(file).getLocation();
debugger = new TestDebugger(service, transmitter, configurator, dtoFactory, localStorageProvider, eventBus,
activeFileHandler, debuggerManager, notificationManager, "id");
doReturn(promiseInfo).when(service).getSessionInfo(SESSION_ID);
doReturn(promiseInfo).when(promiseInfo).then(any(Operation.class));
verify(eventBus).addHandler(eq(WsAgentStateEvent.TYPE), extServerStateHandlerCaptor.capture());
extServerStateHandlerCaptor.getValue().onWsAgentStarted(WsAgentStateEvent.createWsAgentStartedEvent());
debugger.addObserver(observer);
FileType fileType = mock(FileType.class);
doReturn("java").when(fileType).getExtension();
}
@Test
public void testAttachDebugger() throws Exception {
debugger.setDebugSession(null);
final String debugSessionJson = "debugSession";
doReturn(debugSessionJson).when(dtoFactory).toJson(debugSessionDto);
doReturn(mock(StartActionDto.class)).when(dtoFactory).createDto(StartActionDto.class);
Map<String, String> connectionProperties = mock(Map.class);
Promise<DebugSessionDto> promiseDebuggerInfo = mock(Promise.class);
org.eclipse.che.api.core.jsonrpc.commons.reception.MethodNameConfigurator methodNameConfigurator = mock(
org.eclipse.che.api.core.jsonrpc.commons.reception.MethodNameConfigurator.class);
org.eclipse.che.api.core.jsonrpc.commons.reception.ParamsConfigurator paramsConfigurator = mock(
org.eclipse.che.api.core.jsonrpc.commons.reception.ParamsConfigurator.class);
ResultConfiguratorFromOne resultConfiguratorFromOne = mock(ResultConfiguratorFromOne.class);
ConsumerConfiguratorOneToNone operationConfiguratorOneToNone = mock(ConsumerConfiguratorOneToNone.class);
doReturn(methodNameConfigurator).when(configurator).newConfiguration();
doReturn(paramsConfigurator).when(methodNameConfigurator).methodName(anyString());
doReturn(resultConfiguratorFromOne).when(paramsConfigurator).paramsAsDto(anyObject());
doReturn(operationConfiguratorOneToNone).when(resultConfiguratorFromOne).noResult();
doReturn(promiseDebuggerInfo).when(service).connect("id", connectionProperties);
doReturn(promiseVoid).when(promiseDebuggerInfo).then((Function<DebugSessionDto, Void>)any());
doReturn(promiseVoid).when(promiseVoid).catchError((Operation<PromiseError>)any());
Promise<Void> result = debugger.connect(connectionProperties);
assertEquals(promiseVoid, result);
verify(promiseDebuggerInfo).then(argumentCaptorFunctionJavaDebugSessionVoid.capture());
argumentCaptorFunctionJavaDebugSessionVoid.getValue().apply(debugSessionDto);
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
try {
operationPromiseErrorCaptor.getValue().apply(promiseError);
fail("Operation Exception expected");
} catch (OperationException e) {
verify(promiseError).getMessage();
verify(promiseError).getCause();
}
verify(observer).onDebuggerAttached(debuggerDescriptor, promiseVoid);
assertTrue(debugger.isConnected());
verify(localStorage).setItem(eq(AbstractDebugger.LOCAL_STORAGE_DEBUGGER_SESSION_KEY), eq(debugSessionJson));
}
@Test
public void testAttachDebuggerWithConnection() throws Exception {
Map<String, String> connectionProperties = mock(Map.class);
debugger.connect(connectionProperties);
verify(service, never()).connect(any(), any());
}
@Test
public void testDisconnectDebugger() throws Exception {
doReturn(promiseVoid).when(service).disconnect(SESSION_ID);
doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());
debugger.disconnect();
assertFalse(debugger.isConnected());
verify(localStorage).setItem(eq(AbstractDebugger.LOCAL_STORAGE_DEBUGGER_SESSION_KEY), eq(""));
verify(promiseVoid).then(operationVoidCaptor.capture());
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationVoidCaptor.getValue().apply(null);
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(observer, times(2)).onDebuggerDisconnected();
verify(debuggerManager, times(2)).setActiveDebugger(eq(null));
}
@Test
public void testDisconnectDebuggerWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.disconnect();
verify(service, never()).disconnect(any());
}
@Test
public void testResume() throws Exception {
ResumeActionDto resumeAction = mock(ResumeActionDto.class);
doReturn(promiseVoid).when(service).resume(SESSION_ID, resumeAction);
doReturn(resumeAction).when(dtoFactory).createDto(ResumeActionDto.class);
debugger.resume();
verify(observer).onPreResume();
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getCause();
assertTrue(debugger.isConnected());
}
@Test
public void testResumeWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.resume();
verify(service, never()).resume(any(), any());
}
@Test
public void testStepInto() throws Exception {
StepIntoActionDto stepIntoAction = mock(StepIntoActionDto.class);
doReturn(promiseVoid).when(service).stepInto(SESSION_ID, stepIntoAction);
doReturn(stepIntoAction).when(dtoFactory).createDto(StepIntoActionDto.class);
debugger.stepInto();
verify(observer).onPreStepInto();
assertTrue(debugger.isConnected());
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getCause();
}
@Test
public void testStepIntoWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.stepInto();
verify(service, never()).stepInto(any(), any());
}
@Test
public void testStepOver() throws Exception {
StepOverActionDto stepOverAction = mock(StepOverActionDto.class);
doReturn(promiseVoid).when(service).stepOver(SESSION_ID, stepOverAction);
doReturn(stepOverAction).when(dtoFactory).createDto(StepOverActionDto.class);
debugger.stepOver();
verify(observer).onPreStepOver();
assertTrue(debugger.isConnected());
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getCause();
}
@Test
public void testStepOverWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.stepOver();
verify(service, never()).stepOver(any(), any());
}
@Test
public void testStepOut() throws Exception {
StepOutActionDto stepOutAction = mock(StepOutActionDto.class);
doReturn(promiseVoid).when(service).stepOut(SESSION_ID, stepOutAction);
doReturn(stepOutAction).when(dtoFactory).createDto(StepOutActionDto.class);
debugger.stepOut();
verify(observer).onPreStepOut();
assertTrue(debugger.isConnected());
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getCause();
}
@Test
public void testStepOutWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.stepOut();
verify(service, never()).stepOut(any(), any());
}
@Test
public void testAddBreakpoint() throws Exception {
MockSettings mockSettings = new MockSettingsImpl<>().defaultAnswer(RETURNS_SMART_NULLS)
.extraInterfaces(Resource.class);
Project project = mock(Project.class);
when(optional.isPresent()).thenReturn(true);
when(optional.get()).thenReturn(project);
when(project.getPath()).thenReturn(PATH);
VirtualFile virtualFile = mock(VirtualFile.class, mockSettings);
Path path = mock(Path.class);
when(path.toString()).thenReturn(PATH);
when(virtualFile.getLocation()).thenReturn(path);
when(virtualFile.toString()).thenReturn(PATH);
Resource resource = (Resource)virtualFile;
when(resource.getRelatedProject()).thenReturn(optional);
doReturn(promiseVoid).when(service).addBreakpoint(SESSION_ID, breakpointDto);
doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());
when(locationDto.withLineNumber(LINE_NUMBER + 1)).thenReturn(locationDto);
when(locationDto.withResourcePath(PATH)).thenReturn(locationDto);
when(locationDto.withResourceProjectPath(PATH)).thenReturn(locationDto);
when(locationDto.withTarget(anyString())).thenReturn(locationDto);
when(breakpointDto.withLocation(locationDto)).thenReturn(breakpointDto);
when(breakpointDto.withEnabled(true)).thenReturn(breakpointDto);
debugger.addBreakpoint(virtualFile, LINE_NUMBER);
verify(locationDto).withLineNumber(LINE_NUMBER + 1);
verify(locationDto).withTarget(FQN);
verify(locationDto).withResourcePath(PATH);
verify(locationDto).withResourceProjectPath(PATH);
verify(breakpointDto).withLocation(locationDto);
verify(breakpointDto).withEnabled(true);
verify(promiseVoid).then(operationVoidCaptor.capture());
operationVoidCaptor.getValue().apply(null);
verify(observer).onBreakpointAdded(breakpointCaptor.capture());
assertEquals(breakpointCaptor.getValue(), TEST_BREAKPOINT);
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getMessage();
}
@Test
public void testAddBreakpointWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.addBreakpoint(file, LINE_NUMBER);
verify(service, never()).addBreakpoint(any(), any());
verify(observer).onBreakpointAdded(breakpointCaptor.capture());
assertEquals(breakpointCaptor.getValue(), TEST_BREAKPOINT);
}
@Test
public void testDeleteBreakpoint() throws Exception {
doReturn(promiseVoid).when(service).deleteBreakpoint(SESSION_ID, locationDto);
doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());
debugger.deleteBreakpoint(file, LINE_NUMBER);
verify(locationDto).setLineNumber(LINE_NUMBER + 1);
verify(locationDto).setTarget(FQN);
verify(promiseVoid).then(operationVoidCaptor.capture());
operationVoidCaptor.getValue().apply(null);
verify(observer).onBreakpointDeleted(breakpointCaptor.capture());
assertEquals(TEST_BREAKPOINT, breakpointCaptor.getValue());
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getMessage();
}
@Test
public void testDeleteBreakpointWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.deleteBreakpoint(file, LINE_NUMBER);
verify(service, never()).deleteBreakpoint(any(), any());
}
@Test
public void testDeleteAllBreakpoints() throws Exception {
doReturn(promiseVoid).when(service).deleteAllBreakpoints(SESSION_ID);
doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());
debugger.deleteAllBreakpoints();
verify(promiseVoid).then(operationVoidCaptor.capture());
operationVoidCaptor.getValue().apply(null);
verify(observer).onAllBreakpointsDeleted();
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getMessage();
}
@Test
public void testDeleteAllBreakpointsWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.deleteAllBreakpoints();
verify(service, never()).deleteAllBreakpoints(any());
}
@Test
public void testGetValue() throws Exception {
final VariableDto variableDto = mock(VariableDto.class);
final Variable variable = mock(Variable.class);
final Promise<SimpleValueDto> promiseValue = mock(Promise.class);
doReturn(variableDto).when(dtoFactory).createDto(VariableDto.class);
doReturn(mock(VariablePathDto.class)).when(dtoFactory).createDto(VariablePathDto.class);
doReturn(mock(VariablePathDto.class)).when(variable).getVariablePath();
doReturn(Collections.emptyList()).when(variable).getVariables();
doReturn(promiseValue).when(service).getValue(SESSION_ID, variableDto);
doReturn(promiseValue).when(promiseValue).then((Function<SimpleValueDto, Object>)any());
doReturn(promiseValue).when(promiseValue).catchError((Operation<PromiseError>)any());
Promise<SimpleValue> result = debugger.getValue(variable);
assertEquals(promiseValue, result);
}
@Test
public void testGetValueWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.getValue(null);
verify(service, never()).getValue(any(), any());
}
@Test
public void testGetStackFrameDump() throws Exception {
Promise<StackFrameDumpDto> promiseStackFrameDump = mock(Promise.class);
StackFrameDumpDto mockStackFrameDumpDto = mock(StackFrameDumpDto.class);
final String json = "json";
doReturn(json).when(dtoFactory).toJson(mockStackFrameDumpDto);
doReturn(promiseStackFrameDump).when(service).getStackFrameDump(SESSION_ID);
doReturn(promiseStackFrameDump).when(promiseStackFrameDump).then((Function<StackFrameDumpDto, Object>)any());
doReturn(promiseStackFrameDump).when(promiseStackFrameDump).catchError((Operation<PromiseError>)any());
Promise<StackFrameDump> result = debugger.dumpStackFrame();
assertEquals(promiseStackFrameDump, result);
}
@Test
public void testGetStackFrameDumpWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.dumpStackFrame();
verify(service, never()).getStackFrameDump(any());
}
@Test
public void testEvaluateExpression() throws Exception {
final String expression = "a = 1";
Promise<String> promiseString = mock(Promise.class);
doReturn(promiseString).when(service).evaluate(SESSION_ID, expression);
Promise<String> result = debugger.evaluate(expression);
assertEquals(promiseString, result);
}
@Test
public void testEvaluateExpressionWithoutConnection() throws Exception {
debugger.setDebugSession(null);
debugger.evaluate("any");
verify(service, never()).evaluate(any(), any());
}
@Test
public void testChangeVariableValue() throws Exception {
final List<String> path = mock(List.class);
final String newValue = "new-value";
VariablePath variablePath = mock(VariablePathDto.class);
doReturn(path).when(variablePath).getPath();
VariableDto variableDto = mock(VariableDto.class);
doReturn(variableDto).when(dtoFactory).createDto(VariableDto.class);
Variable variable = mock(Variable.class);
doReturn(mock(VariablePathDto.class)).when(dtoFactory).createDto(VariablePathDto.class);
doReturn(variablePath).when(variable).getVariablePath();
doReturn(newValue).when(variable).getValue();
doReturn(Collections.emptyList()).when(variable).getVariables();
doReturn(promiseVoid).when(service).setValue(SESSION_ID, variableDto);
doReturn(promiseVoid).when(promiseVoid).then((Operation<Void>)any());
debugger.setValue(variable);
verify(promiseVoid).then(operationVoidCaptor.capture());
operationVoidCaptor.getValue().apply(null);
verify(observer).onValueChanged(path, newValue);
verify(promiseVoid).catchError(operationPromiseErrorCaptor.capture());
operationPromiseErrorCaptor.getValue().apply(promiseError);
verify(promiseError).getMessage();
}
private class TestDebugger extends AbstractDebugger {
public TestDebugger(DebuggerServiceClient service,
RequestTransmitter transmitter,
RequestHandlerConfigurator configurator,
DtoFactory dtoFactory,
LocalStorageProvider localStorageProvider,
EventBus eventBus,
ActiveFileHandler activeFileHandler,
DebuggerManager debuggerManager,
NotificationManager notificationManager,
String id) {
super(service,
transmitter,
configurator,
dtoFactory,
localStorageProvider,
eventBus,
activeFileHandler,
debuggerManager,
notificationManager,
breakpointManager,
id);
}
@Override
protected String fqnToPath(Location location) {
return PATH;
}
@Nullable
@Override
protected String pathToFqn(VirtualFile file) {
return FQN;
}
@Override
protected DebuggerDescriptor toDescriptor(Map<String, String> connectionProperties) {
return debuggerDescriptor;
}
}
}