Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2000-2015 JetBrains s.r.o.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.execution.testframework.sm.runner;
 
 import  com.intellij.execution.process.ProcessOutputTypes;
 import  com.intellij.execution.testframework.Printer;
 import  com.intellij.openapi.application.Application;
 import  com.intellij.openapi.application.ApplicationManager;
 import  com.intellij.openapi.diagnostic.Logger;
 import  com.intellij.openapi.util.Key;
 import  com.intellij.util.containers.ContainerUtil;
 import  gnu.trove.TIntObjectHashMap;
 import  org.jetbrains.annotations.NotNull;
 import  org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 import java.util.Set;

Author(s):
Sergey Simonchik
 
   private static final Logger LOG = Logger.getInstance(GeneralIdBasedToSMTRunnerEventsConvertor.class.getName());
 
   private final TIntObjectHashMap<NodemyNodeByIdMap = new TIntObjectHashMap<Node>();
   private final Set<NodemyRunningTestNodes = ContainerUtil.newHashSet();
   private final List<SMTRunnerEventsListenermyEventsListeners = ContainerUtil.createLockFreeCopyOnWriteList();
   private final Node myTestsRootNode;
   private final String myTestFrameworkName;
 
   private boolean myIsTestingFinished = false;
   private SMTestLocator myLocator = null;
 
   public GeneralIdBasedToSMTRunnerEventsConvertor(@NotNull SMTestProxy.SMRootTestProxy testsRootProxy, @NotNull String testFrameworkName) {
      = testsRootProxy;
      = new Node(0, nulltestsRootProxy);
      = testFrameworkName;
   }
 
   @Override
   public void setLocator(@NotNull SMTestLocator locator) {
      = locator;
   }
 
   public void addEventsListener(@NotNull SMTRunnerEventsListener listener) {
     .add(listener);
   }
 
   public void onStartTesting() {
     addToInvokeLater(new Runnable() {
       public void run() {
         .setStarted();
         fireOnTestingStarted();
       }
     });
   }
 
   @Override
   public void onTestsReporterAttached() {
     addToInvokeLater(new Runnable() {
       public void run() {
       }
     });
   }
 
   public void onFinishTesting() {
     addToInvokeLater(new Runnable() {
       public void run() {
         if () {
           // has been already invoked!
           return;
         }
          = true;
 
         // We don't know whether process was destroyed by user
         // or it finished after all tests have been run
         // Lets assume, if at finish all nodes except root suite have final state (passed, failed or ignored),
         // then all is ok otherwise process was terminated by user
         boolean completeTree = isTreeComplete();
        if (completeTree) {
          .setFinished();
        } else {
          .setTerminated();
        }
        if (!.isEmpty()) {
          logProblem("Unexpected running nodes: " + );
        }
        .clear();
        .clear();
        fireOnTestingFinished();
      }
    });
  }
  public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) {
     = printerProvider;
  }
  public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        doStartNode(testStartedEventfalse);
      }
    });
  }
  public void onSuiteStarted(@NotNull final TestSuiteStartedEvent suiteStartedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        doStartNode(suiteStartedEventtrue);
      }
    });
  }
  private void doStartNode(@NotNull BaseStartedNodeEvent startedNodeEventboolean suite) {
    Node node = findNode(startedNodeEvent);
    if (node != null) {
      if (node.getState() == . && startedNodeEvent.isRunning()) {
        setNodeAndAncestorsRunning(node);
      }
      else {
        logProblem(startedNodeEvent + " has been already started: " + node + "!");
      }
      return;
    }
    Node parentNode = findValidParentNode(startedNodeEvent);
    if (parentNode == null) {
      return;
    }
    if (!validateNodeId(startedNodeEvent)) {
      return;
    }
    String nodeName = startedNodeEvent.getName();
    SMTestProxy childProxy = new SMTestProxy(nodeNamesuitestartedNodeEvent.getLocationUrl(), true);
    String nodeType = startedNodeEvent.getNodeType();
    if (printerProvider != null && nodeType != null && nodeName != null) {
      Printer printer = printerProvider.getPrinterByType(nodeTypenodeNamestartedNodeEvent.getNodeArgs());
      if (printer != null) {
        childProxy.setPreferredPrinter(printer);
      }
    }
    node = new Node(startedNodeEvent.getId(), parentNodechildProxy);
    .put(startedNodeEvent.getId(), node);
    if ( != null) {
      childProxy.setLocator();
    }
    parentNode.getProxy().addChild(childProxy);
    if (startedNodeEvent.isRunning()) {
    }
  }
  @Nullable
  private Node findValidParentNode(@NotNull BaseStartedNodeEvent startedNodeEvent) {
    int parentId = startedNodeEvent.getParentId();
    if (parentId < 0) {
      logProblem("Parent node id should be non-negative: " + startedNodeEvent + "."true);
      return null;
    }
    Node parentNode = .get(startedNodeEvent.getParentId());
    if (parentNode == null) {
      logProblem("Parent node is undefined for " + startedNodeEvent + "."true);
      return null;
    }
    if (parentNode.getState() != . && parentNode.getState() != .) {
      logProblem("Parent node should be registered or running: " + parentNode + ", " + startedNodeEvent);
      return null;
    }
    return parentNode;
  }
  public void onTestFinished(@NotNull final TestFinishedEvent testFinishedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node node = findNodeToTerminate(testFinishedEvent);
        if (node != null) {
          SMTestProxy testProxy = node.getProxy();
          testProxy.setDuration(testFinishedEvent.getDuration());
          testProxy.setFinished();
          fireOnTestFinished(testProxy);
          terminateNode(node.);
        }
      }
    });
  }
  public void onSuiteFinished(@NotNull final TestSuiteFinishedEvent suiteFinishedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node node = findNodeToTerminate(suiteFinishedEvent);
        if (node != null) {
          SMTestProxy suiteProxy = node.getProxy();
          suiteProxy.setFinished();
          fireOnSuiteFinished(suiteProxy);
          terminateNode(node.);
        }
      }
    });
  }
  @Nullable
  private Node findNodeToTerminate(@NotNull TreeNodeEvent treeNodeEvent) {
    Node node = findNode(treeNodeEvent);
    if (node == null) {
      logProblem("Trying to finish not existent node: " + treeNodeEvent);
      return null;
    }
    return node;
  }
  public void onUncapturedOutput(@NotNull final String textfinal Key outputType) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node activeNode = findActiveNode();
        SMTestProxy activeProxy = activeNode.getProxy();
        if (ProcessOutputTypes.STDERR.equals(outputType)) {
          activeProxy.addStdErr(text);
        } else if (ProcessOutputTypes.SYSTEM.equals(outputType)) {
          activeProxy.addSystemOutput(text);
        } else {
          activeProxy.addStdOutput(textoutputType);
        }
      }
    });
  }
  public void onError(@NotNull final String localizedMessage,
                      @Nullable final String stackTrace,
                      final boolean isCritical) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node activeNode = findActiveNode();
        SMTestProxy activeProxy = activeNode.getProxy();
        activeProxy.addError(localizedMessagestackTraceisCritical);
      }
    });
  }
  public void onCustomProgressTestsCategory(@Nullable final String categoryName,
                                            final int testCount) {
    addToInvokeLater(new Runnable() {
      public void run() {
        fireOnCustomProgressTestsCategory(categoryNametestCount);
      }
    });
  }
  public void onCustomProgressTestStarted() {
    addToInvokeLater(new Runnable() {
      public void run() {
      }
    });
  }
  public void onCustomProgressTestFinished() {
    addToInvokeLater(new Runnable() {
      public void run() {
      }
    });
  }
  public void onCustomProgressTestFailed() {
    addToInvokeLater(new Runnable() {
      public void run() {
      }
    });
  }
  public void onTestFailure(@NotNull final TestFailedEvent testFailedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node node = findNodeToTerminate(testFailedEvent);
        if (node == null) {
          return;
        }
        SMTestProxy testProxy = node.getProxy();
        String comparisonFailureActualText = testFailedEvent.getComparisonFailureActualText();
        String comparisonFailureExpectedText = testFailedEvent.getComparisonFailureExpectedText();
        String failureMessage = testFailedEvent.getLocalizedFailureMessage();
        String stackTrace = testFailedEvent.getStacktrace();
        if (comparisonFailureActualText != null && comparisonFailureExpectedText != null) {
          testProxy.setTestComparisonFailed(failureMessagestackTrace,
                                            comparisonFailureActualTextcomparisonFailureExpectedText);
        } else if (comparisonFailureActualText == null && comparisonFailureExpectedText == null) {
          testProxy.setTestFailed(failureMessagestackTracetestFailedEvent.isTestError());
        } else {
          logProblem("Comparison failure actual and expected texts should be both null or not null.\n"
                     + "Expected:\n"
                     + comparisonFailureExpectedText + "\n"
                     + "Actual:\n"
                     + comparisonFailureActualText);
        }
        // fire event
        fireOnTestFailed(testProxy);
        terminateNode(node.);
      }
    });
  }
  public void onTestIgnored(@NotNull final TestIgnoredEvent testIgnoredEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node node = findNodeToTerminate(testIgnoredEvent);
        if (node != null) {
          SMTestProxy testProxy = node.getProxy();
          testProxy.setTestIgnored(testIgnoredEvent.getIgnoreComment(), testIgnoredEvent.getStacktrace());
          // fire event
          fireOnTestIgnored(testProxy);
          terminateNode(node.);
        }
      }
    });
  }
  public void onTestOutput(@NotNull final TestOutputEvent testOutputEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        Node node = findNode(testOutputEvent);
        if (node == null) {
          logProblem("Test wasn't started! But " + testOutputEvent + "!");
          return;
        }
        SMTestProxy testProxy = node.getProxy();
        if (testOutputEvent.isStdOut()) {
          testProxy.addStdOutput(testOutputEvent.getText(), ProcessOutputTypes.STDOUT);
        } else {
          testProxy.addStdErr(testOutputEvent.getText());
        }
      }
    });
  }
  public void onTestsCountInSuite(final int count) {
    addToInvokeLater(new Runnable() {
      public void run() {
        fireOnTestsCountInSuite(count);
      }
    });
  }
  private boolean validateNodeId(@NotNull TreeNodeEvent treeNodeEvent) {
    int nodeId = treeNodeEvent.getId();
    if (nodeId <= 0) {
      logProblem("Node id should be positive: " + treeNodeEvent + "."true);
      return false;
    }
    return true;
  }
  @Nullable
  private Node findNode(@NotNull TreeNodeEvent treeNodeEvent) {
    if (!validateNodeId(treeNodeEvent)) {
      return null;
    }
    return .get(treeNodeEvent.getId());
  }
  private void fireOnTestingStarted() {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestingStarted();
    }
  }
  private void fireOnTestingFinished() {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestingFinished();
    }
  }
  private void fireOnTestsCountInSuite(final int count) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestsCountInSuite(count);
    }
  }
  private void fireOnTestStarted(final SMTestProxy test) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestStarted(test);
    }
  }
  private void fireOnTestFinished(final SMTestProxy test) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestFinished(test);
    }
  }
  private void fireOnTestFailed(final SMTestProxy test) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestFailed(test);
    }
  }
  private void fireOnTestIgnored(final SMTestProxy test) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onTestIgnored(test);
    }
  }
  private void fireOnSuiteStarted(final SMTestProxy suite) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onSuiteStarted(suite);
    }
  }
  private void fireOnSuiteFinished(final SMTestProxy suite) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onSuiteFinished(suite);
    }
  }
  private void fireOnCustomProgressTestsCategory(@Nullable final String categoryNameint testCount) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onCustomProgressTestsCategory(categoryNametestCount);
    }
  }
  private void fireOnCustomProgressTestStarted() {
    for (SMTRunnerEventsListener listener : ) {
      listener.onCustomProgressTestStarted();
    }
  }
  private void fireOnCustomProgressTestFinished() {
    for (SMTRunnerEventsListener listener : ) {
      listener.onCustomProgressTestFinished();
    }
  }
  private void fireOnCustomProgressTestFailed() {
    for (SMTRunnerEventsListener listener : ) {
      listener.onCustomProgressTestFailed();
    }
  }
  /*
   * Remove listeners,  etc
   */
  public void dispose() {
    super.dispose();
    addToInvokeLater(new Runnable() {
      public void run() {
        .clear();
        if (!.isEmpty()) {
          Application application = ApplicationManager.getApplication();
          if (!application.isHeadlessEnvironment() && !application.isUnitTestMode()) {
            logProblem("Not all events were processed!");
          }
        }
        .clear();
        .clear();
      }
    });
  }
  private void setNodeAndAncestorsRunning(@NotNull Node lowestNode) {
    Node node = lowestNode;
    while (node != null && node !=  && node.getState() == .) {
      node.setState(.this);
      SMTestProxy proxy = node.getProxy();
      proxy.setStarted();
      if (proxy.isSuite()) {
        fireOnSuiteStarted(proxy);
      } else {
        .add(lowestNode);
        fireOnTestStarted(proxy);
      }
      node = node.getParentNode();
    }
  }
  private void terminateNode(@NotNull Node node, @NotNull State terminateState) {
    node.setState(terminateStatethis);
  }
  @NotNull
  private Node findActiveNode() {
    if (.isEmpty()) {
      return ;
    }
    return .iterator().next();
  }
  private void logProblem(@NotNull String msg) {
    logProblem(msg, SMTestRunnerConnectionUtil.isInDebugMode());
  }
  private void logProblem(@NotNull String msgboolean throwError) {
    final String text = "[" +  + "] " + msg;
    if (throwError) {
      .error(text);
    }
    else {
      .warn(text);
    }
  }
  private enum State {
    NOT_RUNNING, RUNNING, FINISHED, FAILED, IGNORED
  }
  private static class Node {
    private final int myId;
    private final Node myParentNode;
    private final SMTestProxy myProxy;
    private State myState;
    Node(int id, @Nullable Node parentNode, @NotNull SMTestProxy proxy) {
       = id;
       = parentNode;
       = proxy;
       = .;
    }
    public int getId() {
      return ;
    }
    @Nullable
    public Node getParentNode() {
      return ;
    }
    @NotNull
    public SMTestProxy getProxy() {
      return ;
    }
    @NotNull
    public State getState() {
      return ;
    }
    public void setState(@NotNull State newState, @NotNull GeneralIdBasedToSMTRunnerEventsConvertor convertor) {
      boolean accepted = false;
      if ( == . ||  == .) {
        accepted = .ordinal() < newState.ordinal();
      }
      if (accepted) {
         = newState;
      }
      else {
        convertor.logProblem("Illegal state change [" +  + " -> " + newState + "]: " + toString(), false);
      }
    }
    @Override
    public boolean equals(Object o) {
      if (this == oreturn true;
      if (o == null || getClass() != o.getClass()) return false;
      Node node = (Node)o;
      return  == node.myId;
    }
    @Override
    public int hashCode() {
      return ;
    }
    @Override
    public String toString() {
      return "{" +
             "id=" +  +
             ", parentId=" + ( != null ? String.valueOf(.getId()) : "<undefined>") +
             ", name='" + .getName() +
             "', isSuite=" + .isSuite() +
             ", state=" +  +
             '}';
    }
  }
New to GrepCode? Check out our FAQ X