public AddAssertionPanel(Assertable assertable) {
   super(
       "Add Assertion",
       "Select the source property and which assertion to apply below ",
       HelpUrls.ADD_ASSERTION_PANEL);
   this.assertable = assertable;
   assertionEntryRenderer.setAssertable(assertable);
   categoriesListRenderer.setAssertable(assertable);
   selectionListener = new InternalListSelectionListener();
   categoriesAssertionsMap =
       AssertionCategoryMapping.getCategoriesAssertionsMap(assertable, recentAssertionHandler);
   // load interfaces or have a issue with table and cell renderer
   WsdlProject project = (WsdlProject) ModelSupport.getModelItemProject(assertable.getModelItem());
   for (Interface inf : project.getInterfaceList()) {
     try {
       // There seems to be no good reason to load the definitions for rest interfaces
       // hence that call has been removed for the time being.
       if (inf instanceof WsdlInterface) {
         ((WsdlInterface) inf).getWsdlContext().loadIfNecessary();
       }
     } catch (Exception e) {
       // TODO Improve this
       e.printStackTrace();
     }
   }
 }
    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);
        }
      }
    }
  @Override
  public void afterStep(
      TestCaseRunner testRunner, TestCaseRunContext runContext, TestStepResult result) {
    super.afterStep(testRunner, runContext, result);
    TestStep currentStep = runContext.getCurrentStep();

    if (currentStep instanceof Assertable) {
      Assertable requestStep = (Assertable) currentStep;
      for (int c = 0; c < requestStep.getAssertionCount(); c++) {
        TestAssertion assertion = requestStep.getAssertionAt(c);
        log.info("Assertion [" + assertion.getName() + "] has status " + assertion.getStatus());
        if (assertion.getStatus() == AssertionStatus.FAILED) {
          for (AssertionError error : assertion.getErrors()) {
            log.error("ASSERTION FAILED -> " + error.getMessage());
          }

          assertions.add(assertion);
          assertionResults.put(assertion, (WsdlTestStepResult) result);
        }

        testAssertionCount++;
      }
    }

    String countPropertyName = currentStep.getName() + " run count";
    Long count = (Long) runContext.getProperty(countPropertyName);
    if (count == null) {
      count = new Long(0);
    }

    runContext.setProperty(countPropertyName, new Long(count.longValue() + 1));

    if (result.getStatus() == TestStepStatus.FAILED || exportAll) {
      try {
        String exportSeparator = System.getProperty(SOAPUI_EXPORT_SEPARATOR, "-");

        TestCase tc = currentStep.getTestCase();
        String nameBase =
            StringUtils.createFileName(tc.getTestSuite().getName(), '_')
                + exportSeparator
                + StringUtils.createFileName(tc.getName(), '_')
                + exportSeparator
                + StringUtils.createFileName(currentStep.getName(), '_')
                + "-"
                + count.longValue()
                + "-"
                + result.getStatus();

        WsdlTestCaseRunner callingTestCaseRunner =
            (WsdlTestCaseRunner) runContext.getProperty("#CallingTestCaseRunner#");

        if (callingTestCaseRunner != null) {
          WsdlTestCase ctc = callingTestCaseRunner.getTestCase();
          WsdlRunTestCaseTestStep runTestCaseTestStep =
              (WsdlRunTestCaseTestStep) runContext.getProperty("#CallingRunTestCaseStep#");

          nameBase =
              StringUtils.createFileName(ctc.getTestSuite().getName(), '_')
                  + exportSeparator
                  + StringUtils.createFileName(ctc.getName(), '_')
                  + exportSeparator
                  + StringUtils.createFileName(runTestCaseTestStep.getName(), '_')
                  + exportSeparator
                  + StringUtils.createFileName(tc.getTestSuite().getName(), '_')
                  + exportSeparator
                  + StringUtils.createFileName(tc.getName(), '_')
                  + exportSeparator
                  + StringUtils.createFileName(currentStep.getName(), '_')
                  + "-"
                  + count.longValue()
                  + "-"
                  + result.getStatus();
        }

        String absoluteOutputFolder = getAbsoluteOutputFolder(ModelSupport.getModelItemProject(tc));
        String fileName = absoluteOutputFolder + File.separator + nameBase + ".txt";

        if (result.getStatus() == TestStepStatus.FAILED) {
          log.error(currentStep.getName() + " failed, exporting to [" + fileName + "]");
        }

        new File(fileName).getParentFile().mkdirs();

        PrintWriter writer = new PrintWriter(fileName);
        result.writeTo(writer);
        writer.close();

        // write attachments
        if (result instanceof MessageExchange) {
          Attachment[] attachments = ((MessageExchange) result).getResponseAttachments();
          if (attachments != null && attachments.length > 0) {
            for (int c = 0; c < attachments.length; c++) {
              fileName = nameBase + "-attachment-" + (c + 1) + ".";

              Attachment attachment = attachments[c];
              String contentType = attachment.getContentType();
              if (!"application/octet-stream".equals(contentType)
                  && contentType != null
                  && contentType.indexOf('/') != -1) {
                fileName += contentType.substring(contentType.lastIndexOf('/') + 1);
              } else {
                fileName += "dat";
              }

              fileName = absoluteOutputFolder + File.separator + fileName;

              FileOutputStream outFile = new FileOutputStream(fileName);
              Tools.writeAll(outFile, attachment.getInputStream());
              outFile.close();
            }
          }
        }

        exportCount++;
      } catch (Exception e) {
        log.error("Error saving failed result: " + e, e);
      }
    }

    testStepCount++;
  }
  public Response sendRequest(SubmitContext submitContext, Request request) throws Exception {
    AbstractHttpRequestInterface<?> httpRequest = (AbstractHttpRequestInterface<?>) request;

    HttpClient httpClient = HttpClientSupport.getHttpClient();
    ExtendedHttpMethod httpMethod = createHttpMethod(httpRequest);
    boolean createdState = false;

    HttpState httpState = (HttpState) submitContext.getProperty(SubmitContext.HTTP_STATE_PROPERTY);
    if (httpState == null) {
      httpState = new HttpState();
      submitContext.setProperty(SubmitContext.HTTP_STATE_PROPERTY, httpState);
      createdState = true;
    }

    HostConfiguration hostConfiguration = new HostConfiguration();

    String localAddress = System.getProperty("soapui.bind.address", httpRequest.getBindAddress());
    if (localAddress == null || localAddress.trim().length() == 0)
      localAddress = SoapUI.getSettings().getString(HttpSettings.BIND_ADDRESS, null);

    if (localAddress != null && localAddress.trim().length() > 0) {
      try {
        hostConfiguration.setLocalAddress(InetAddress.getByName(localAddress));
      } catch (Exception e) {
        SoapUI.logError(e);
      }
    }

    submitContext.removeProperty(RESPONSE);
    submitContext.setProperty(HTTP_METHOD, httpMethod);
    submitContext.setProperty(POST_METHOD, httpMethod);
    submitContext.setProperty(HTTP_CLIENT, httpClient);
    submitContext.setProperty(REQUEST_CONTENT, httpRequest.getRequestContent());
    submitContext.setProperty(HOST_CONFIGURATION, hostConfiguration);
    submitContext.setProperty(WSDL_REQUEST, httpRequest);
    submitContext.setProperty(RESPONSE_PROPERTIES, new StringToStringMap());

    for (RequestFilter filter : filters) {
      filter.filterRequest(submitContext, httpRequest);
    }

    try {
      Settings settings = httpRequest.getSettings();

      // custom http headers last so they can be overridden
      StringToStringMap headers = httpRequest.getRequestHeaders();
      for (String header : headers.keySet()) {
        String headerValue = headers.get(header);
        headerValue = PropertyExpander.expandProperties(submitContext, headerValue);
        httpMethod.setRequestHeader(header, headerValue);
      }

      // do request
      WsdlProject project = (WsdlProject) ModelSupport.getModelItemProject(httpRequest);
      WssCrypto crypto = null;
      if (project != null) {
        crypto =
            project
                .getWssContainer()
                .getCryptoByName(
                    PropertyExpander.expandProperties(submitContext, httpRequest.getSslKeystore()));
      }

      if (crypto != null && WssCrypto.STATUS_OK.equals(crypto.getStatus())) {
        hostConfiguration
            .getParams()
            .setParameter(
                SoapUIHostConfiguration.SOAPUI_SSL_CONFIG,
                crypto.getSource() + " " + crypto.getPassword());
      }

      // dump file?
      httpMethod.setDumpFile(
          PathUtils.expandPath(
              httpRequest.getDumpFile(), (AbstractWsdlModelItem<?>) httpRequest, submitContext));

      // include request time?
      if (settings.getBoolean(HttpSettings.INCLUDE_REQUEST_IN_TIME_TAKEN))
        httpMethod.initStartTime();

      // submit!
      httpClient.executeMethod(hostConfiguration, httpMethod, httpState);
      httpMethod.getTimeTaken();
    } catch (Throwable t) {
      httpMethod.setFailed(t);

      if (t instanceof Exception) throw (Exception) t;

      SoapUI.logError(t);
      throw new Exception(t);
    } finally {
      for (int c = filters.size() - 1; c >= 0; c--) {
        filters.get(c).afterRequest(submitContext, httpRequest);
      }

      if (!submitContext.hasProperty(RESPONSE)) {
        createDefaultResponse(submitContext, httpRequest, httpMethod);
      }

      Response response = (Response) submitContext.getProperty(BaseHttpRequestTransport.RESPONSE);
      StringToStringMap responseProperties =
          (StringToStringMap)
              submitContext.getProperty(BaseHttpRequestTransport.RESPONSE_PROPERTIES);

      for (String key : responseProperties.keySet()) {
        response.setProperty(key, responseProperties.get(key));
      }

      if (httpMethod != null) {
        httpMethod.releaseConnection();
      } else log.error("PostMethod is null");

      if (createdState) {
        submitContext.setProperty(SubmitContext.HTTP_STATE_PROPERTY, null);
      }
    }

    return (Response) submitContext.getProperty(BaseHttpRequestTransport.RESPONSE);
  }