@Override
  public void perform(WsdlTestSuite testSuite, Object param) {

    if (IntegrationUtils.forceSaveProject(testSuite.getProject())) {

      if (!StartLoadUI.testCajoConnection()) {
        if (UISupport.confirm(
            StartLoadUI.LOADUI_LAUNCH_QUESTION, StartLoadUI.LOADUI_LAUNCH_TITLE)) {
          StartLoadUI.launchLoadUI();
        }
        return;
      }

      XFormDialog dialog = ADialogBuilder.buildDialog(TestSuiteForm.class);

      dialog.setOptions(TestSuiteForm.LOADUIPROJECT, IntegrationUtils.getAvailableProjects());
      if (!StringUtils.isNullOrEmpty(IntegrationUtils.getOpenedProjectName())) {
        dialog.setValue(TestSuiteForm.LOADUIPROJECT, IntegrationUtils.getOpenedProjectName());
      } else {
        dialog.setValue(TestSuiteForm.LOADUIPROJECT, IntegrationUtils.CREATE_NEW_OPTION);
      }
      List<String> testSuiteLoadTests = new ArrayList<String>();
      for (TestCase testCase : testSuite.getTestCaseList()) {
        for (LoadTest loadTest : testCase.getLoadTestList()) {
          testSuiteLoadTests.add(testCase.getName() + " - " + loadTest.getName());
        }
      }
      String[] names = new String[testSuiteLoadTests.size()];
      for (int c = 0; c < names.length; c++) {
        names[c] = testSuiteLoadTests.get(c);
      }
      dialog.setOptions(TestSuiteForm.LOADTESTS, names);
      if (dialog.show()) {
        if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
          String loadUIProject = dialog.getValue(TestSuiteForm.LOADUIPROJECT);
          String openedProjectName = IntegrationUtils.getOpenedProjectName();
          if (!StringUtils.isNullOrEmpty(openedProjectName)
              && !loadUIProject.equals(openedProjectName)
              && IntegrationUtils.checkOpenedLoadUIProjectForClose()) {
            return;
          }
          String[] soapuiLoadTests =
              StringUtils.toStringArray(
                  ((XFormMultiSelectList) dialog.getFormField(TestSuiteForm.LOADTESTS))
                      .getSelectedOptions());
          if (soapuiLoadTests.length == 0) {
            UISupport.showErrorMessage("No LoadTests selected.");
            return;
          }
          try {
            IntegrationUtils.exportMultipleLoadTestToLoadUI(
                testSuite, soapuiLoadTests, loadUIProject);
          } catch (IOException e) {
            UISupport.showInfoMessage("Error while opening selected loadUI project");
            return;
          }
        }
      }
    }
  }
  protected void createTransfer(XmlTreeNode tn) {
    if (dialog == null) buildDialog();

    this.treeNode = tn;

    StringToStringMap values = dialog.show(initValues());
    if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
      createTransfer(values);
    }
  }
  public boolean configure() {
    if (dialog == null) buildDialog();

    StringToStringMap values = new StringToStringMap();
    values.put(CONTENT, token);
    values.put(IGNORE_CASE, ignoreCase);
    values.put(USE_REGEX, useRegEx);

    values = dialog.show(values);
    if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
      token = values.get(CONTENT);
      ignoreCase = values.getBoolean(IGNORE_CASE);
      useRegEx = values.getBoolean(USE_REGEX);
    }

    setConfiguration(createConfiguration());
    return true;
  }
  @Override
  public boolean configure() {
    if (dialog == null) buildDialog();
    if (dialog.show()) {
      assertionSpecificExposureList = createListFromTable();
      includeProjectSpecific =
          Boolean.valueOf(
              dialog
                  .getFormField(SensitiveInformationConfigDialog.INCLUDE_PROJECT_SPECIFIC)
                  .getValue());
      includeGlobal =
          Boolean.valueOf(
              dialog.getFormField(SensitiveInformationConfigDialog.INCLUDE_GLOBAL).getValue());
      setConfiguration(createConfiguration());

      return true;
    }
    return false;
  }
  @Override
  public void perform(RestMockService mockService, Object param) {
    XFormDialog dialog = ADialogBuilder.buildDialog(Form.class);
    dialog.setOptions(Form.HTTP_METHOD, RestRequestInterface.HttpMethod.getMethodsAsStringArray());
    dialog.setValue(Form.HTTP_METHOD, RestRequestInterface.HttpMethod.GET.name());

    JTextFieldFormField formField = (JTextFieldFormField) dialog.getFormField(Form.RESOURCE_PATH);
    formField.getComponent().requestFocus();

    while (dialog.show()) {
      String resourcePath = dialog.getValue(Form.RESOURCE_PATH);
      String httpMethod = dialog.getValue(Form.HTTP_METHOD);

      if (StringUtils.hasContent(resourcePath)) {
        mockService.addEmptyMockAction(
            RestRequestInterface.HttpMethod.valueOf(httpMethod), resourcePath);
        break;
      }
      UISupport.showInfoMessage("The resource path can not be empty");
    }
  }
  public void perform(SecurityTest securityTest, Object param) {
    if (dialog == null) {
      XFormDialogBuilder builder = XFormFactory.createDialogBuilder("SecurityTest Options");
      form = builder.createForm("Basic");
      form.addCheckBox(FAIL_ON_ERROR, "Fail on error")
          .addFormFieldListener(
              new XFormFieldListener() {

                public void valueChanged(XFormField sourceField, String newValue, String oldValue) {
                  form.getFormField(FAIL_SECURITYTEST_ON_ERROR)
                      .setEnabled(!Boolean.parseBoolean(newValue));
                }
              });
      form.addCheckBox(FAIL_SECURITYTEST_ON_ERROR, "Fail SecurityTest if it has failed TestSteps");

      dialog =
          builder.buildDialog(
              builder.buildOkCancelHelpActions(HelpUrls.SECURITYTESTEDITOR_HELP_URL),
              "Specify general options for this SecurityTest",
              UISupport.OPTIONS_ICON);
    }

    StringToStringMap values = new StringToStringMap();

    values.put(FAIL_ON_ERROR, String.valueOf(securityTest.getFailOnError()));
    values.put(
        FAIL_SECURITYTEST_ON_ERROR, String.valueOf(securityTest.getFailSecurityTestOnScanErrors()));
    values = dialog.show(values);

    if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
      try {
        securityTest.setFailOnError(Boolean.parseBoolean(values.get(FAIL_ON_ERROR)));
        securityTest.setFailSecurityTestOnScanErrors(
            Boolean.parseBoolean(values.get(FAIL_SECURITYTEST_ON_ERROR)));

      } catch (Exception e1) {
        UISupport.showErrorMessage(e1.getMessage());
      }
    }
  }
Esempio n. 7
0
  public boolean configure() {
    if (dialog == null) buildDialog();

    StringToStringMap values = new StringToStringMap();
    values.put(ASSERT_ACTION, assertWsaAction);
    values.put(ASSERT_TO, assertWsaTo);
    values.put(ASSERT_REPLY_TO, assertWsaReplyTo);
    values.put(ASSERT_MESSAGE_ID, assertWsaMessageId);
    // values.put(ASSERT_RELATES_TO, assertWsaRelatesTo);
    // values.put(ASSERT_REPLY_TO_REF_PARAMS, assertReplyToRefParams);
    // values.put(ASSERT_FAULT_TO_REF_PARAMS, assertFaultToRefParams);

    values = dialog.show(values);
    if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
      assertWsaAction = values.getBoolean(ASSERT_ACTION);
      assertWsaTo = values.getBoolean(ASSERT_TO);
      assertWsaReplyTo = values.getBoolean(ASSERT_REPLY_TO);
      assertWsaMessageId = values.getBoolean(ASSERT_MESSAGE_ID);
      // assertWsaRelatesTo = values.getBoolean(ASSERT_RELATES_TO);
      // assertReplyToRefParams = values
      // .getBoolean(ASSERT_REPLY_TO_REF_PARAMS);
      // assertFaultToRefParams = values
      // .getBoolean(ASSERT_FAULT_TO_REF_PARAMS);
    }

    wsaAssertionConfiguration =
        new WsaAssertionConfiguration(
            assertWsaAction,
            assertWsaTo,
            assertWsaReplyTo,
            assertWsaMessageId,
            false,
            false,
            false);
    setConfiguration(createConfiguration());
    return true;
  }
  public boolean configure() {
    if (dialog == null) {
      buildDialog();
    }

    StringToStringMap values = new StringToStringMap();

    values.put(NAME_FIELD, getName());
    values.put(MINIMUM_REQUESTS_FIELD, String.valueOf(minRequests));
    values.put(MAX_AVERAGE_FIELD, String.valueOf(maxAverage));
    values.put(TEST_STEP_FIELD, getTargetStep());
    values.put(MAX_ERRORS_FIELD, String.valueOf(maxErrors));
    values.put(SAMPLE_INTERVAL_FIELD, String.valueOf(sampleInterval));

    dialog.setOptions(TEST_STEP_FIELD, getTargetStepOptions(true));
    values = dialog.show(values);

    if (dialog.getReturnValue() == XFormDialog.OK_OPTION) {
      try {
        minRequests = Integer.parseInt(values.get(MINIMUM_REQUESTS_FIELD));
        maxAverage = Integer.parseInt(values.get(MAX_AVERAGE_FIELD));
        maxErrors = Integer.parseInt(values.get(MAX_ERRORS_FIELD));
        sampleInterval = Integer.parseInt(values.get(SAMPLE_INTERVAL_FIELD));
        setName(values.get(NAME_FIELD));
        setTargetStep(values.get(TEST_STEP_FIELD));
      } catch (Exception e) {
        UISupport.showErrorMessage(e.getMessage());
      }

      updateConfiguration();

      return true;
    }

    return false;
  }
  public void perform(RestService target, Object param) {
    try {
      if (dialog == null) {
        dialog = ADialogBuilder.buildDialog(Form.class);
      }

      Settings settings = target.getSettings();
      dialog.setValue(Form.OUTPUT_FOLDER, settings.getString(REPORT_DIRECTORY_SETTING, ""));

      if (!dialog.show()) {
        return;
      }

      settings.setString(REPORT_DIRECTORY_SETTING, dialog.getValue(Form.OUTPUT_FOLDER));

      final File reportDirectory = new File(settings.getString(REPORT_DIRECTORY_SETTING, ""));
      String reportDirAbsolutePath = reportDirectory.getAbsolutePath();
      String filename = reportDirAbsolutePath + File.separatorChar + "report.xml";
      String reportUrl = transform(target, reportDirAbsolutePath, filename);
      Tools.openURL(reportUrl);
    } catch (Exception e) {
      UISupport.showErrorMessage(e);
    }
  }
Esempio n. 10
0
  public void perform(WsdlTestCase testCase, Object param) {
    if (dialog == null) {
      dialog = ADialogBuilder.buildDialog(Form.class);
      dialog
          .getFormField(Form.PROJECT)
          .addFormFieldListener(
              new XFormFieldListener() {

                public void valueChanged(XFormField sourceField, String newValue, String oldValue) {
                  if (newValue.equals(CREATE_NEW_OPTION))
                    dialog.setOptions(Form.TESTSUITE, new String[] {CREATE_NEW_OPTION});
                  else {
                    Project project = SoapUI.getWorkspace().getProjectByName(newValue);
                    dialog.setOptions(
                        Form.TESTSUITE,
                        ModelSupport.getNames(
                            project.getTestSuiteList(), new String[] {CREATE_NEW_OPTION}));
                  }
                }
              });
      dialog
          .getFormField(Form.CLONE_DESCRIPTION)
          .addFormFieldListener(
              new XFormFieldListener() {

                public void valueChanged(XFormField sourceField, String newValue, String oldValue) {
                  if (dialog.getBooleanValue(Form.CLONE_DESCRIPTION)) {
                    dialog.getFormField(Form.DESCRIPTION).setEnabled(false);
                  } else {
                    dialog.getFormField(Form.DESCRIPTION).setEnabled(true);
                  }
                }
              });
    }

    dialog.setBooleanValue(Form.MOVE, false);
    dialog.setBooleanValue(Form.CLONE_DESCRIPTION, true);
    dialog.getFormField(Form.DESCRIPTION).setEnabled(false);
    dialog.setValue(Form.DESCRIPTION, testCase.getDescription());
    dialog.setValue(Form.NAME, "Copy of " + testCase.getName());
    WorkspaceImpl workspace = testCase.getTestSuite().getProject().getWorkspace();
    dialog.setOptions(
        Form.PROJECT,
        ModelSupport.getNames(workspace.getOpenProjectList(), new String[] {CREATE_NEW_OPTION}));

    dialog.setValue(Form.PROJECT, testCase.getTestSuite().getProject().getName());

    dialog.setOptions(
        Form.TESTSUITE,
        ModelSupport.getNames(
            testCase.getTestSuite().getProject().getTestSuiteList(),
            new String[] {CREATE_NEW_OPTION}));

    dialog.setValue(Form.TESTSUITE, testCase.getTestSuite().getName());
    boolean hasLoadTests = testCase.getLoadTestCount() > 0;
    dialog.setBooleanValue(Form.CLONE_LOADTESTS, hasLoadTests);
    dialog.getFormField(Form.CLONE_LOADTESTS).setEnabled(hasLoadTests);

    if (dialog.show()) {
      String targetProjectName = dialog.getValue(Form.PROJECT);
      String targetTestSuiteName = dialog.getValue(Form.TESTSUITE);
      String name = dialog.getValue(Form.NAME);

      WsdlProject project = testCase.getTestSuite().getProject();
      WsdlTestSuite targetTestSuite = null;
      Set<Interface> requiredInterfaces = new HashSet<Interface>();

      // to another project project?
      if (!targetProjectName.equals(project.getName())) {
        // get required interfaces
        for (int y = 0; y < testCase.getTestStepCount(); y++) {
          WsdlTestStep testStep = testCase.getTestStepAt(y);
          requiredInterfaces.addAll(testStep.getRequiredInterfaces());
        }

        project = (WsdlProject) workspace.getProjectByName(targetProjectName);
        if (project == null) {
          targetProjectName = UISupport.prompt("Enter name for new Project", "Clone TestCase", "");
          if (targetProjectName == null) return;

          try {
            project = workspace.createProject(targetProjectName, null);
          } catch (SoapUIException e) {
            UISupport.showErrorMessage(e);
          }

          if (project == null) return;
        }

        if (requiredInterfaces.size() > 0 && project.getInterfaceCount() > 0) {
          Map<String, Interface> bindings = new HashMap<String, Interface>();
          for (Interface iface : requiredInterfaces) {
            bindings.put(iface.getTechnicalId(), iface);
          }

          for (Interface iface : project.getInterfaceList()) {
            bindings.remove(iface.getTechnicalId());
          }

          requiredInterfaces.retainAll(bindings.values());
        }

        if (requiredInterfaces.size() > 0) {
          String msg =
              "Target project [" + targetProjectName + "] is missing required Interfaces;\r\n\r\n";
          for (Interface iface : requiredInterfaces) {
            msg += iface.getName() + " [" + iface.getTechnicalId() + "]\r\n";
          }
          msg += "\r\nThese will be cloned to the targetProject as well";

          if (!UISupport.confirm(msg, "Clone TestCase")) return;

          for (Interface iface : requiredInterfaces) {
            project.importInterface((AbstractInterface<?>) iface, true, true);
          }
        }
      }

      targetTestSuite = project.getTestSuiteByName(targetTestSuiteName);
      if (targetTestSuite == null) {
        targetTestSuiteName =
            UISupport.prompt(
                "Specify name for new TestSuite",
                "Clone TestCase",
                "Copy of " + testCase.getTestSuite().getName());
        if (targetTestSuiteName == null) return;

        targetTestSuite = project.addNewTestSuite(targetTestSuiteName);
      }

      boolean move = dialog.getBooleanValue(Form.MOVE);
      WsdlTestCase newTestCase =
          targetTestSuite.importTestCase(
              testCase, name, -1, dialog.getBooleanValue(Form.CLONE_LOADTESTS), !move);
      UISupport.select(newTestCase);

      if (move) {
        testCase.getTestSuite().removeTestCase(testCase);
      }
      boolean cloneDescription = dialog.getBooleanValue(Form.CLONE_DESCRIPTION);
      if (!cloneDescription) {
        newTestCase.setDescription(dialog.getValue(Form.DESCRIPTION));
      }
    }
  }
Esempio n. 11
0
    public Credentials getCredentials(final AuthScope authScope) {
      if (authScope == null) {
        throw new IllegalArgumentException("Authentication scope may not be null");
      }

      //	if( cache.containsKey( authScope ) )
      //	{
      //	return cache.get( authScope );
      //	}

      String pw = getPassword();
      if (pw == null) pw = "";

      if (AuthPolicy.NTLM.equalsIgnoreCase(authScope.getScheme())
          || AuthPolicy.SPNEGO.equalsIgnoreCase(authScope.getScheme())) {
        String workstation = "";
        try {
          workstation = InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
        }

        if (hasCredentials()) {
          log.info("Returning url credentials");
          return new NTCredentials(getUsername(), pw, workstation, null);
        }

        log.info(
            authScope.getHost() + ":" + authScope.getPort() + " requires Windows authentication");
        if (ntDialog == null) {
          buildNtDialog();
        }

        StringToStringMap values = new StringToStringMap();
        values.put(
            "Info",
            "Authentication required for ["
                + authScope.getHost()
                + ":"
                + authScope.getPort()
                + "]");
        ntDialog.setValues(values);

        if (ntDialog.show()) {
          values = ntDialog.getValues();
          NTCredentials credentials =
              new NTCredentials(
                  values.get("Username"),
                  values.get("Password"),
                  workstation,
                  values.get("Domain"));

          cache.put(authScope, credentials);
          return credentials;
        }
      } else if (AuthPolicy.BASIC.equalsIgnoreCase(authScope.getScheme())
          || AuthPolicy.DIGEST.equalsIgnoreCase(authScope.getScheme())) {
        if (hasCredentials()) {
          log.info("Returning url credentials");
          UsernamePasswordCredentials credentials =
              new UsernamePasswordCredentials(getUsername(), pw);
          cache.put(authScope, credentials);
          return credentials;
        }

        log.info(
            authScope.getHost()
                + ":"
                + authScope.getPort()
                + " requires authentication with the realm '"
                + authScope.getRealm()
                + "'");
        ShowDialog showDialog = new ShowDialog();
        showDialog.values.put(
            "Info",
            "Authentication required for ["
                + authScope.getHost()
                + ":"
                + authScope.getPort()
                + "]");

        UISupport.getUIUtils().runInUIThreadIfSWT(showDialog);
        if (showDialog.result) {
          UsernamePasswordCredentials credentials =
              new UsernamePasswordCredentials(
                  showDialog.values.get("Username"), showDialog.values.get("Password"));
          cache.put(authScope, credentials);
          return credentials;
        }
      }

      return null;
    }
Esempio n. 12
0
    public void actionPerformed(ActionEvent e) {
      if (dialog == null) {
        dialog = ADialogBuilder.buildDialog(LoadOptionsForm.class);
      }

      Project project = ModelSupport.getModelItemProject(holder.getModelItem());
      if (project != null) {
        FileFormField fileFormField = (FileFormField) dialog.getFormField(LoadOptionsForm.FILE);
        String currentDirectory = extractFileChooserPathForProject(project);
        fileFormField.setCurrentDirectory(currentDirectory);
      }

      dialog
          .getFormField(LoadOptionsForm.DELETEREMAINING)
          .setEnabled(holder instanceof MutableTestPropertyHolder);
      dialog
          .getFormField(LoadOptionsForm.CREATEMISSING)
          .setEnabled(holder instanceof MutableTestPropertyHolder);

      if (dialog.show()) {
        try {
          BufferedReader reader =
              new BufferedReader(new FileReader(dialog.getValue(LoadOptionsForm.FILE)));

          String line = reader.readLine();
          int count = 0;

          Set<String> names = new HashSet<String>(Arrays.asList(holder.getPropertyNames()));

          while (line != null) {
            if (line.trim().length() > 0 && !(line.charAt(0) == '#')) {
              int ix = line.indexOf('=');
              if (ix > 0) {
                String name = line.substring(0, ix).trim();
                String value = line.length() > ix ? line.substring(ix + 1) : "";

                // read multiline value
                if (value.endsWith("\\")) {
                  value = value.substring(0, value.length() - 1);

                  String ln = reader.readLine();
                  while (ln != null && ln.endsWith("\\")) {
                    value += ln.substring(0, ln.length() - 1);
                    ln = reader.readLine();
                  }

                  if (ln != null) {
                    value += ln;
                  }
                  if (ln == null) {
                    break;
                  }
                }

                if (holder.hasProperty(name)) {
                  count++;
                  holder.getProperty(name).setValue(value);
                  holder.setPropertyValue(name, value);
                } else if (dialog.getBooleanValue(LoadOptionsForm.CREATEMISSING)
                    && holder instanceof MutableTestPropertyHolder) {
                  TestProperty prop = ((MutableTestPropertyHolder) holder).addProperty(name);
                  if (!prop.isReadOnly()) {
                    prop.setValue(value);
                    if (prop instanceof RestParameter) {
                      ((RestParameter) prop).setDefaultValue(value);
                    }
                  }
                  count++;
                }

                names.remove(name);
              }
            }

            line = reader.readLine();
          }

          if (dialog.getBooleanValue(LoadOptionsForm.DELETEREMAINING)
              && holder instanceof MutableTestPropertyHolder) {
            for (String name : names) {
              ((MutableTestPropertyHolder) holder).removeProperty(name);
            }
          }

          reader.close();
          UISupport.showInfoMessage("Added/Updated " + count + " properties from file");
        } catch (Exception ex) {
          UISupport.showErrorMessage(ex);
        }
      }
    }
Esempio n. 13
0
  public void perform(WsdlTestRequestStep target, Object param) {
    this.testStep = target;

    if (dialog == null) {
      dialog = ADialogBuilder.buildDialog(Form.class);
      dialog
          .getFormField(Form.INTERFACE)
          .addFormFieldListener(
              new XFormFieldListener() {

                public void valueChanged(XFormField sourceField, String newValue, String oldValue) {
                  WsdlProject project = testStep.getTestCase().getTestSuite().getProject();
                  dialog.setOptions(
                      Form.OPERATION,
                      ModelSupport.getNames(
                          project.getInterfaceByName(newValue).getOperationList()));
                  dialog.setValue(Form.OPERATION, testStep.getOperationName());
                }
              });

      dialog
          .getFormField(Form.RECREATE_REQUEST)
          .addFormFieldListener(
              new XFormFieldListener() {

                public void valueChanged(XFormField sourceField, String newValue, String oldValue) {
                  boolean enabled = Boolean.parseBoolean(newValue);

                  dialog.getFormField(Form.CREATE_OPTIONAL).setEnabled(enabled);
                  dialog.getFormField(Form.KEEP_EXISTING).setEnabled(enabled);
                }
              });

      dialog.getFormField(Form.CREATE_OPTIONAL).setEnabled(false);
      dialog.getFormField(Form.KEEP_EXISTING).setEnabled(false);
    }

    WsdlProject project = target.getTestCase().getTestSuite().getProject();
    dialog.setOptions(
        Form.INTERFACE,
        ModelSupport.getNames(
            project.getInterfaceList(),
            new ModelSupport.InterfaceTypeFilter(WsdlInterfaceFactory.WSDL_TYPE)));
    dialog.setValue(Form.INTERFACE, target.getInterfaceName());

    dialog.setOptions(
        Form.OPERATION,
        ModelSupport.getNames(
            project.getInterfaceByName(target.getInterfaceName()).getOperationList()));
    dialog.setValue(Form.OPERATION, target.getOperationName());
    dialog.setValue(Form.NAME, target.getName());

    if (dialog.show()) {
      String ifaceName = dialog.getValue(Form.INTERFACE);
      String operationName = dialog.getValue(Form.OPERATION);

      WsdlInterface iface = (WsdlInterface) project.getInterfaceByName(ifaceName);
      WsdlOperation operation = iface.getOperationByName(operationName);
      target.setOperation(operation);

      String name = dialog.getValue(Form.NAME).trim();
      if (name.length() > 0 && !target.getName().equals(name)) target.setName(name);

      if (dialog.getBooleanValue(Form.RECREATE_REQUEST)) {
        String req = operation.createRequest(dialog.getBooleanValue(Form.CREATE_OPTIONAL));
        if (req == null) {
          UISupport.showErrorMessage("Request creation failed");
          return;
        }

        WsdlTestRequest request = target.getTestRequest();
        if (dialog.getBooleanValue(Form.KEEP_EXISTING)) {
          req = XmlUtils.transferValues(request.getRequestContent(), req);
        }

        request.setRequestContent(req);
      }
    }
  }