Java ILaunch类代码示例

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
public DSPDebugTarget(ILaunch launch, Process process, InputStream in, OutputStream out,
		Map<String, Object> launchArguments) throws CoreException {
	super(null);
	this.launch = launch;
	this.process = process;

	DebugLauncher<IDebugProtocolServer> debugProtocolLauncher = DebugLauncher.createLauncher(this,
			IDebugProtocolServer.class, in, out, true, new PrintWriter(System.out));

	debugProtocolFuture = debugProtocolLauncher.startListening();
	debugProtocolServer = debugProtocolLauncher.getRemoteProxy();

	complete(debugProtocolServer.initialize(new InitializeRequestArguments().setClientID("lsp4e")
			.setAdapterID((String) launchArguments.get("type")).setPathFormat("path")));

	Object object = launchArguments.get("program");
	targetName = Objects.toString(object, "Debug Adapter Target");

	complete(debugProtocolServer.launch(Either.forLeft(launchArguments)));
	complete(debugProtocolServer.configurationDone());
	IBreakpointManager breakpointManager = getBreakpointManager();
	breakpointManager.addBreakpointListener(this);
	breakpointManager.addBreakpointManagerListener(this);
	breakpointManagerEnablementChanged(breakpointManager.isEnabled());
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Override
protected void appendAdditionalLaunchParameters(LaunchParameterValues launchParameterValues) {
	ILaunch launch = launchParameterValues.getLaunch();
	if (launch==null){
		throw new IllegalStateException("launch missing");
	}
	String projectName;
	try {
		ILaunchConfiguration configuration = launch.getLaunchConfiguration();
		
		projectName = configuration.getAttribute(PROPERTY_PROJECTNAME, (String)null);
		
		String configuredTasksValue= configuration.getAttribute(PROPERTY_TASKS, "");
		String tasksToExecute = variableReplacement.replace(configuredTasksValue, JUNIT_PREFERENCES.getDefaultTestTaskType().getTestTasks());
		
		launchParameterValues.setPostJob(new ImportGradleJunitResultsJob("Import gradle junit results",projectName,true));
		launchParameterValues.setOverriddenTasks(tasksToExecute);
	} catch (CoreException e) {
		JunitUtil.logError("Was not able to add additional launch parameters", e);
	}
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testRemoveSessionsFor1() {
  ILaunch launch0 = new Launch(null, null, null);
  ILaunch launch1 = new Launch(null, null, null);
  ICoverageSession s0 = new DummySession();
  ICoverageSession s1 = new DummySession();
  manager.addSession(s0, false, launch0);
  manager.addSession(s1, true, launch1);
  listener.clear();

  manager.removeSessionsFor(launch1);

  assertEquals(Arrays.asList(s0), manager.getSessions());
  assertSame(s0, manager.getActiveSession());
  reflistener.sessionRemoved(s1);
  reflistener.sessionActivated(s0);
  assertEquals(reflistener, listener);
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testRemoveSessionsFor2() {
  ILaunch launch0 = new Launch(null, null, null);
  ILaunch launch1 = new Launch(null, null, null);
  ILaunch launch2 = new Launch(null, null, null);
  ICoverageSession s0 = new DummySession();
  ICoverageSession s1 = new DummySession();
  manager.addSession(s0, false, launch0);
  manager.addSession(s1, true, launch1);
  listener.clear();

  manager.removeSessionsFor(launch2);

  assertEquals(Arrays.asList(s0, s1), manager.getSessions());
  assertSame(s1, manager.getActiveSession());
  assertEquals(reflistener, listener);
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testRemoveSessionsFor3() {
  ILaunch launch0 = new Launch(null, null, null);
  ILaunch launch1 = new Launch(null, null, null);
  ICoverageSession s0 = new DummySession();
  ICoverageSession s1 = new DummySession();
  ICoverageSession s2 = new DummySession();
  manager.addSession(s0, true, launch0);
  manager.addSession(s1, true, launch1);
  manager.addSession(s2, true, launch1);
  listener.clear();

  manager.removeSessionsFor(launch1);

  assertEquals(Arrays.asList(s0), manager.getSessions());
  assertSame(s0, manager.getActiveSession());
  reflistener.sessionRemoved(s1);
  reflistener.sessionRemoved(s2);
  reflistener.sessionActivated(s0);
  assertEquals(reflistener, listener);
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
public static String getLaunchText(ILaunch launch) {
  // new launch configuration
  final ILaunchConfiguration config = launch.getLaunchConfiguration();
  if (config == null) {
    return UIMessages.DumpExecutionDataUnknownLaunch_value;
  }
  StringBuilder sb = new StringBuilder(config.getName());
  sb.append(" ["); //$NON-NLS-1$
  try {
    sb.append(config.getType().getName());
  } catch (CoreException e) {
    EclEmmaUIPlugin.log(e);
  }
  sb.append("]"); //$NON-NLS-1$
  return sb.toString();
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
public void addSession(ICoverageSession session, boolean activate,
    ILaunch launch) {
  synchronized (lock) {
    if (session == null) {
      throw new IllegalArgumentException();
    }
    if (!sessions.contains(session)) {
      sessions.add(session);
      if (launch != null) {
        List<ICoverageSession> l = launchmap.get(launch);
        if (l == null) {
          l = new ArrayList<ICoverageSession>();
          launchmap.put(launch, l);
        }
        l.add(session);
      }
      fireSessionAdded(session);
    }
    if (activate) {
      activeSession = session;
      fireSessionActivated(session);
    }
  }
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
/**
 * Determines all current coverage launches which are running.
 *
 * @return list of running coverage launches
 */
public static List<ICoverageLaunch> getRunningCoverageLaunches() {
  final List<ICoverageLaunch> result = new ArrayList<ICoverageLaunch>();
  for (final ILaunch launch : DebugPlugin.getDefault().getLaunchManager()
      .getLaunches()) {
    if (launch instanceof ICoverageLaunch && !launch.isTerminated()) {
      result.add((ICoverageLaunch) launch);
    }
  }
  return result;
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testLaunchWithProjectThatDoesNotExistThrowsIllegalArgumentException()
    throws CoreException {
  ILaunchConfiguration configuration = mockILaunchConfiguration();
  when(project.exists()).thenReturn(false);

  String mode = "run";
  ILaunch launch = mock(ILaunch.class);

  try {
    dataflowDelegate.launch(configuration, mode, launch, monitor);
    fail();
  } catch (IllegalArgumentException ex) {
    assertTrue(
        ex.getMessage().contains("Project with name Test-project,Name must exist to launch."));
  }
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testLaunchWithValidLaunchConfigurationCreatesJsonCredential() throws CoreException {
  ILaunchConfiguration configuration = mockILaunchConfiguration();
  when(configuration.getAttribute(
      "com.google.cloud.dataflow.eclipse.ALL_ARGUMENT_VALUES", new HashMap<String, String>()))
      .thenReturn(ImmutableMap.of("accountEmail", "[email protected]"));

  Map<String, String> environmentVariables = new HashMap<>();
  ILaunchConfigurationWorkingCopy expectedConfiguration =
      mockILaunchConfigurationWorkingCopy(environmentVariables);
  when(configuration.copy("dataflow_tmp_config_working_copy-testConfiguration"))
      .thenReturn(expectedConfiguration);

  WritableDataflowPreferences globalPreferences = WritableDataflowPreferences.global();
  globalPreferences.setDefaultAccountEmail("[email protected]");
  globalPreferences.save();

  dataflowDelegate.launch(configuration, "run" /* mode */, mock(ILaunch.class), monitor);

  String jsonCredentialPath = environmentVariables.get("GOOGLE_APPLICATION_CREDENTIALS");
  assertNotNull(jsonCredentialPath);
  assertTrue(Files.exists(Paths.get(jsonCredentialPath)));
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
/**
 * Waits until {@code launch} terminates or {@code monitor} is canceled. if the monitor is
 * canceled, attempts to terminate the launch before returning.
 *
 * @return true if the launch terminated normally; false otherwise
 */
@VisibleForTesting
static boolean waitUntilLaunchTerminates(ILaunch launch, IProgressMonitor monitor)
    throws InterruptedException, DebugException {
  while (!launch.isTerminated() && !monitor.isCanceled()) {
    Thread.sleep(100 /*ms*/);
  }

  if (monitor.isCanceled()) {
    launch.terminate();
    return false;
  }
  for (IProcess process : launch.getProcesses()) {
    if (process.getExitValue() != 0) {
      return false;
    }
  }
  return true;
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Override
protected IPath getDeployArtifact(IPath safeWorkingDirectory, IProgressMonitor monitor)
    throws CoreException {
  SubMonitor subMonitor = SubMonitor.convert(monitor, 100);

  try {
    ILaunchConfiguration config = createMavenPackagingLaunchConfiguration(project);
    ILaunch launch = config.launch("run", subMonitor.newChild(10));
    if (!waitUntilLaunchTerminates(launch, subMonitor.newChild(90))) {
      throw new OperationCanceledException();
    }
    return getFinalArtifactPath(project);
  } catch (InterruptedException ex) {
    throw new OperationCanceledException();
  }
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@VisibleForTesting
void checkConflictingLaunches(ILaunchConfigurationType launchConfigType, String mode,
    DefaultRunConfiguration runConfig, ILaunch[] launches) throws CoreException {

  for (ILaunch launch : launches) {
    if (launch.isTerminated()
        || launch.getLaunchConfiguration() == null
        || launch.getLaunchConfiguration().getType() != launchConfigType) {
      continue;
    }
    IServer otherServer = ServerUtil.getServer(launch.getLaunchConfiguration());
    DefaultRunConfiguration otherRunConfig =
        generateServerRunConfiguration(launch.getLaunchConfiguration(), otherServer, mode);
    IStatus conflicts = checkConflicts(runConfig, otherRunConfig,
        new MultiStatus(Activator.PLUGIN_ID, 0,
            Messages.getString("conflicts.with.running.server", otherServer.getName()), //$NON-NLS-1$
            null));
    if (!conflicts.isOK()) {
      throw new CoreException(StatusUtil.filter(conflicts));
    }
  }
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Test
public void testWaitUntilLaunchTerminates_atLeastOneNonZeroExit()
    throws DebugException, InterruptedException {
  IProcess process = mock(IProcess.class);
  when(process.getExitValue()).thenReturn(0);
  IProcess nonZeroExitProcess = mock(IProcess.class);
  when(nonZeroExitProcess.getExitValue()).thenReturn(1);

  ILaunch launch = mock(ILaunch.class);
  when(launch.isTerminated()).thenReturn(true);
  when(launch.getProcesses()).thenReturn(new IProcess[] {process, nonZeroExitProcess});

  boolean normalExit = FlexMavenPackagedProjectStagingDelegate.waitUntilLaunchTerminates(
      launch, new NullProgressMonitor());
  assertFalse(normalExit);
}
 

import org.eclipse.debug.core.ILaunch; //导入依赖的package包/类
@Override
public void launchesTerminated(ILaunch[] launches) {
	boolean found = false;
	for (int i = 0; i < launches.length; i++) {
		if (launches[i].equals(launch)) {
			found = true;
			break;
		}
	}
	if (!found || notified) {
		return;
	}
	notified = true;
	if (success) {
		succeededCallback.run();
	}
	DebugPlugin.getDefault().getLaunchManager().removeLaunchListener(this);
}