import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  super.checkConfiguration();

  if (StringUtil.isEmptyOrSpaces(myFolderName) && myTestType == TestType.TEST_FOLDER) {
    throw new RuntimeConfigurationError(PyBundle.message("runcfg.unittest.no_folder_name"));
  }

  if (StringUtil.isEmptyOrSpaces(getScriptName()) && myTestType != TestType.TEST_FOLDER) {
    throw new RuntimeConfigurationError(PyBundle.message("runcfg.unittest.no_script_name"));
  }

  if (StringUtil.isEmptyOrSpaces(myClassName) && (myTestType == TestType.TEST_METHOD || myTestType == TestType.TEST_CLASS)) {
    throw new RuntimeConfigurationError(PyBundle.message("runcfg.unittest.no_class_name"));
  }

  if (StringUtil.isEmptyOrSpaces(myMethodName) && (myTestType == TestType.TEST_METHOD || myTestType == TestType.TEST_FUNCTION)) {
    throw new RuntimeConfigurationError(PyBundle.message("runcfg.unittest.no_method_name"));
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  JavaParametersUtil.checkAlternativeJRE(getConfiguration());
  ProgramParametersUtil.checkWorkingDirectoryExist(
    getConfiguration(), getConfiguration().getProject(), getConfiguration().getConfigurationModule().getModule());
  final String dirName = getConfiguration().getPersistentData().getDirName();
  if (dirName == null || dirName.isEmpty()) {
    throw new RuntimeConfigurationError("Directory is not specified");
  }
  final VirtualFile file = LocalFileSystem.getInstance().findFileByPath(FileUtil.toSystemIndependentName(dirName));
  if (file == null) {
    throw new RuntimeConfigurationWarning("Directory \'" + dirName + "\' is not found");
  }
  final Module module = getConfiguration().getConfigurationModule().getModule();
  if (module == null) {
    throw new RuntimeConfigurationError("Module to choose classpath from is not specified");
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  // Our handler check is not valid when we don't have BlazeProjectData.
  if (BlazeProjectDataManager.getInstance(getProject()).getBlazeProjectData() == null) {
    throw new RuntimeConfigurationError(
        "Configuration cannot be run until project has been synced.");
  }
  if (Strings.isNullOrEmpty(targetPattern)) {
    throw new RuntimeConfigurationError(
        String.format(
            "You must specify a %s target expression.", Blaze.buildSystemName(getProject())));
  }
  if (!targetPattern.startsWith("//")) {
    throw new RuntimeConfigurationError(
        "You must specify the full target expression, starting with //");
  }
  String error = TargetExpression.validate(targetPattern);
  if (error != null) {
    throw new RuntimeConfigurationError(error);
  }
  handler.checkConfiguration();
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  super.checkConfiguration();

  Label label = getTarget();
  if (label == null) {
    throw new RuntimeConfigurationError("Select a target to run");
  }
  TargetInfo target = TargetFinder.findTargetInfo(getProject(), label);
  if (target == null) {
    throw new RuntimeConfigurationError("The selected target does not exist.");
  }
  if (!IntellijPluginRule.isPluginTarget(target)) {
    throw new RuntimeConfigurationError("The selected target is not an intellij_plugin");
  }
  if (!IdeaJdkHelper.isIdeaJdk(pluginSdk)) {
    throw new RuntimeConfigurationError("Select an IntelliJ Platform Plugin SDK");
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  if (artifactPointer == null || artifactPointer.getArtifact() == null) {
    throw new RuntimeConfigurationError(
        GctBundle.message("appengine.run.server.artifact.missing"));
  }

  if (!CloudSdkService.getInstance().isValidCloudSdk()) {
    throw new RuntimeConfigurationError(
        GctBundle.message("appengine.run.server.sdk.misconfigured.panel.message"));
  }

  if (ProjectRootManager.getInstance(commonModel.getProject()).getProjectSdk() == null) {
    throw new RuntimeConfigurationError(GctBundle.getString("appengine.run.server.nosdk"));
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withNoAppEngineComponent_throwsException() {
  setUpValidFlexConfiguration();
  when(mockCloudSdkService.validateCloudSdk())
      .thenReturn(ImmutableSet.of(NO_APP_ENGINE_COMPONENT));

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockAppEngineDeployable, project));
  assertThat(error.getMessage())
      .contains(
          "Server is misconfigured: The Cloud SDK does not contain the app-engine-java "
              + "component.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withUserSpecifiedSource_andNoArtifactPath_throwsException() {
  setUpValidFlexConfiguration();
  when(mockUserSpecifiedPathDeploymentSource.isValid()).thenReturn(true);
  when(mockUserSpecifiedPathDeploymentSource.getEnvironment())
      .thenReturn(AppEngineEnvironment.APP_ENGINE_FLEX);
  configuration.setUserSpecifiedArtifactPath("");

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockUserSpecifiedPathDeploymentSource, project));
  assertThat(error).hasMessage("Browse to a JAR or WAR file.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withNoAppYaml_throwsException() throws Exception {
  setUpValidFlexConfiguration();

  FacetManager.getInstance(module)
      .getFacetByType(AppEngineFlexibleFacet.getFacetType().getId())
      .getConfiguration()
      .setAppYamlPath(null);

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockAppEngineDeployable, project));
  assertThat(error).hasMessage("Browse to an app.yaml file.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withInvalidAppYaml_throwsException() throws Exception {
  setUpValidFlexConfiguration();

  FacetManager.getInstance(module)
      .getFacetByType(AppEngineFlexibleFacet.getFacetType().getId())
      .getConfiguration()
      .setAppYamlPath("/some/invalid/file");

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockAppEngineDeployable, project));
  assertThat(error)
      .hasMessage(
          "The specified app.yaml configuration file does not exist or is not a valid file.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withNoDockerDirectory_throwsException() throws Exception {
  setUpValidCustomFlexConfiguration();

  FacetManager.getInstance(module)
      .getFacetByType(AppEngineFlexibleFacet.getFacetType().getId())
      .getConfiguration()
      .setDockerDirectory(null);

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockAppEngineDeployable, project));
  assertThat(error).hasMessage("Browse to a Docker directory.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Test
public void checkConfiguration_withNoDockerfile_throwsException() throws Exception {
  setUpValidCustomFlexConfiguration();

  FacetManager.getInstance(module)
      .getFacetByType(AppEngineFlexibleFacet.getFacetType().getId())
      .getConfiguration()
      .setDockerDirectory(emptyDirectory.getPath());

  RuntimeConfigurationError error =
      expectThrows(
          RuntimeConfigurationError.class,
          () ->
              configuration.checkConfiguration(
                  mockRemoteServer, mockAppEngineDeployable, project));
  assertThat(error).hasMessage("There is no Dockerfile in specified directory.");
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
protected void requireCabalVersionMinimum(double minimumVersion, @NotNull String errorMessage) throws RuntimeConfigurationException {
    final HaskellBuildSettings buildSettings = HaskellBuildSettings.getInstance(getProject());
    final String cabalPath = buildSettings.getCabalPath();
    if (cabalPath.isEmpty()) {
        throw new RuntimeConfigurationError("Path to cabal is not set.");
    }
    GeneralCommandLine cabalCmdLine = new GeneralCommandLine(cabalPath, "--numeric-version");
    Either<ExecUtil.ExecError, String> result = ExecUtil.readCommandLine(cabalCmdLine);
    if (result.isLeft()) {
        //noinspection ThrowableResultOfMethodCallIgnored
        ExecUtil.ExecError e = EitherUtil.unsafeGetLeft(result);
        NotificationUtil.displaySimpleNotification(
            NotificationType.ERROR, getProject(), "cabal", e.getMessage()
        );
        throw new RuntimeConfigurationError("Failed executing cabal to check its version: " + e.getMessage());
    }
    final String out = EitherUtil.unsafeGetRight(result);
    final Matcher m = EXTRACT_CABAL_VERSION_REGEX.matcher(out);
    if (!m.find()) {
        throw new RuntimeConfigurationError("Could not parse cabal version: '" + out + "'");
    }
    final Double actualVersion = Double.parseDouble(m.group(1));
    if (actualVersion < minimumVersion) {
        throw new RuntimeConfigurationError(errorMessage);
    }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  JavaParametersUtil.checkAlternativeJRE(myConfiguration);
  ProgramParametersUtil.checkWorkingDirectoryExist(myConfiguration, myConfiguration.getProject(), myConfiguration.getConfigurationModule().getModule());
  final String dirName = myConfiguration.getPersistentData().getDirName();
  if (dirName == null || dirName.isEmpty()) {
    throw new RuntimeConfigurationError("Directory is not specified");
  }
  final VirtualFile file = LocalFileSystem.getInstance().findFileByPath(FileUtil.toSystemIndependentName(dirName));
  if (file == null) {
    throw new RuntimeConfigurationWarning("Directory \'" + dirName + "\' is not found");
  }
  final Module module = myConfiguration.getConfigurationModule().getModule();
  if (module == null) {
    throw new RuntimeConfigurationError("Module to choose classpath from is not specified");
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
protected void applyCoreTo(SC configuration) throws ConfigurationException {
  String email = getEmailTextField().getText();
  if (StringUtil.isEmpty(email)) {
    throw new RuntimeConfigurationError("Email required");
  }
  String password = new String(getPasswordField().getPassword());
  if (StringUtil.isEmpty(password)) {
    throw new RuntimeConfigurationError("Password required");
  }

  configuration.setEmail(email);
  configuration.setPassword(password);
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration(@NotNull final ClientLibraryDescription description, final @Nullable Project project,
                               final @Nullable JComponent component) throws RuntimeConfigurationError {
  if (!isDownloaded(description)) {
    throw new RuntimeConfigurationError("Client libraries were not downloaded", new Runnable() {
      @Override
      public void run() {
        download(description, project, component);
      }
    });
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration() throws RuntimeConfigurationException {
  JavaParametersUtil.checkAlternativeJRE(getConfiguration());
  ProgramParametersUtil.checkWorkingDirectoryExist(
    getConfiguration(), getConfiguration().getProject(), getConfiguration().getConfigurationModule().getModule());
  final String category = getConfiguration().getPersistentData().getCategory();
  if (category == null || category.isEmpty()) {
    throw new RuntimeConfigurationError("Category is not specified");
  }
  final JavaRunConfigurationModule configurationModule = getConfiguration().getConfigurationModule();
  if (getSourceScope() == null) {
    configurationModule.checkForWarning();
  }
  configurationModule.findNotNullClass(category);
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
/**
 * Finds the top error, as determined by {@link ValidationError#compareTo(Object)}. If it is
 * fatal, it is thrown as a {@link RuntimeConfigurationError}; otherwise it is thrown as a {@link
 * RuntimeConfigurationWarning}. If no errors exist, nothing is thrown.
 */
public static void throwTopConfigurationError(List<ValidationError> errors)
    throws RuntimeConfigurationException {
  if (errors.isEmpty()) {
    return;
  }
  // TODO: Do something with the extra error information? Error count?
  ValidationError topError = Ordering.natural().max(errors);
  if (topError.isFatal()) {
    throw new RuntimeConfigurationError(topError.getMessage(), topError.getQuickfix());
  }
  throw new RuntimeConfigurationWarning(topError.getMessage(), topError.getQuickfix());
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
public void validate(String buildSystemName) throws RuntimeConfigurationException {
  if (getCommandState().getCommand() == null) {
    throw new RuntimeConfigurationError("You must specify a command.");
  }
  String blazeBinaryString = getBlazeBinaryState().getBlazeBinary();
  if (blazeBinaryString != null && !(new File(blazeBinaryString).exists())) {
    throw new RuntimeConfigurationError(buildSystemName + " binary does not exist");
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
@Override
public void checkConfiguration(
    RemoteServer<?> server, DeploymentSource deploymentSource, Project project)
    throws RuntimeConfigurationException {
  if (!(deploymentSource instanceof AppEngineDeployable)) {
    throw new RuntimeConfigurationError(
        GctBundle.message("appengine.deployment.invalid.source.error"));
  }

  AppEngineDeployable deployable = (AppEngineDeployable) deploymentSource;
  checkCommonConfig(deployable);
  if (deployable.getEnvironment() != null && deployable.getEnvironment().isFlexible()) {
    checkFlexConfig(deployable, project);
  }
}
 

import com.intellij.execution.configurations.RuntimeConfigurationError; //导入依赖的package包/类
private void checkCommonConfig(AppEngineDeployable deployable) throws RuntimeConfigurationError {
  Set<CloudSdkValidationResult> sdkValidationResult =
      CloudSdkService.getInstance().validateCloudSdk();
  if (!sdkValidationResult.isEmpty()) {
    CloudSdkValidationResult result = Iterables.getFirst(sdkValidationResult, null);
    throw new RuntimeConfigurationError(
        GctBundle.message("appengine.flex.config.server.error", result.getMessage()));
  }

  check(
      deployable instanceof UserSpecifiedPathDeploymentSource || deployable.isValid(),
      "appengine.config.deployment.source.error");
  check(
      StringUtils.isNotBlank(cloudProjectName), "appengine.flex.config.project.missing.message");
}