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.AbstractTestProxy;
 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.openapi.util.text.StringUtil;
 import  com.intellij.util.ObjectUtils;
 import  com.intellij.util.containers.ContainerUtil;
 import  org.jetbrains.annotations.NotNull;
 import  org.jetbrains.annotations.Nullable;
 import  org.jetbrains.annotations.TestOnly;
 
 import java.util.*;

This class fires events to SMTRunnerEventsListener in event dispatch thread.

Author(s):
Roman Chernyatchik
 
   private static final Logger LOG = Logger.getInstance(GeneralToSMTRunnerEventsConvertor.class.getName());
 
   private final Set<AbstractTestProxy> myFailedTestsSet = new HashSet<AbstractTestProxy>();
   private final TestSuiteStack mySuitesStack = new TestSuiteStack();
   private final List<SMTRunnerEventsListenermyEventsListeners = ContainerUtil.createLockFreeCopyOnWriteList();
   private final String myTestFrameworkName;
 
   private boolean myIsTestingFinished;
   private SMTestLocator myLocator = null;
   private boolean myTreeBuildBeforeStart = false;
 
   public GeneralToSMTRunnerEventsConvertor(@NotNull SMTestProxy.SMRootTestProxy testsRootNode, @NotNull String testFrameworkName) {
      = testsRootNode;
      = testFrameworkName;
   }
 
   @Override
   public void setLocator(@NotNull SMTestLocator locator) {
      = locator;
   }
 
   public void addEventsListener(@NotNull final SMTRunnerEventsListener listener) {
     .add(listener);
   }
 
   public void onStartTesting() {
     addToInvokeLater(new Runnable() {
       public void run() {
         .setStarted();
 
         //fire
         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 suites except root suite are passed
        // then all is ok otherwise process was terminated by user
          .setTerminated();
        }
        .clear();
        .setFinished();
        //fire events
        fireOnTestingFinished();
      }
    });
  }
  public void onRootPresentationAdded(final String rootNamefinal String commentfinal String rootLocation) {
    addToInvokeLater(new Runnable() {
      @Override
      public void run() {
        .setPresentation(rootName);
        .setComment(comment);
        .setRootLocationUrl(rootLocation);
        if ( != null) {
        }
      }
    });
  }
  public void onSuiteTreeNodeAdded(final String testNamefinal String locationHint) {
     = true;
    addToInvokeLater(new Runnable() {
      @Override
      public void run() {
        final SMTestProxy testProxy = new SMTestProxy(testNamefalselocationHint);
        if ( != null) {
          testProxy.setLocator();
        }
        getCurrentSuite().addChild(testProxy);
        fireOnSuiteTreeNodeAdded(testProxy);
      }
    });
  }
  public void onSuiteTreeStarted(final String suiteNamefinal String locationHint) {
     = true;
    addToInvokeLater(new Runnable() {
      @Override
      public void run() {
        final SMTestProxy parentSuite = getCurrentSuite();
        final SMTestProxy newSuite = new SMTestProxy(suiteNametruelocationHint);
        if ( != null) {
          newSuite.setLocator();
        }
        parentSuite.addChild(newSuite);
        .pushSuite(newSuite);
        fireOnSuiteTreeStarted(newSuite);
      }
    });
  }
  public void onSuiteTreeEnded(final String suiteName) {
    addToInvokeLater(new Runnable() {
      @Override
      public void run() {
        .popSuite(suiteName);
      }
    });
  }
  public void setPrinterProvider(@NotNull TestProxyPrinterProvider printerProvider) {
  }
  public void onTestStarted(@NotNull final TestStartedEvent testStartedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final String testName = testStartedEvent.getName();
        final String locationUrl = testStartedEvent.getLocationUrl();
        final boolean isConfig = testStartedEvent.isConfig();
        final String fullName = getFullTestName(testName);
        if (.containsKey(fullName)) {
          //Duplicated event
          logProblem("Test [" + fullName + "] has been already started");
          if (SMTestRunnerConnectionUtil.isInDebugMode()) {
            return;
          }
        }
        SMTestProxy parentSuite = getCurrentSuite();
        SMTestProxy testProxy = findChildByName(parentSuitefullName);
        if (testProxy == null) {
          // creates test
          testProxy = new SMTestProxy(testNamefalselocationUrl);
          testProxy.setConfig(isConfig);
          if ( != null) {
            testProxy.setLocator();
          }
          parentSuite.addChild(testProxy);
        }
        // adds to running tests map
        .put(fullNametestProxy);
        //Progress started
        testProxy.setStarted();
        //fire events
        fireOnTestStarted(testProxy);
      }
    });
  }
  public void onSuiteStarted(@NotNull final TestSuiteStartedEvent suiteStartedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final String suiteName = suiteStartedEvent.getName();
        final String locationUrl = suiteStartedEvent.getLocationUrl();
        SMTestProxy parentSuite = getCurrentSuite();
        SMTestProxy newSuite = findChildByName(parentSuitesuiteName);
        if (newSuite == null) {
          //new suite
          newSuite = new SMTestProxy(suiteNametruelocationUrl);
          if ( != null) {
            newSuite.setLocator();
          }
          parentSuite.addChild(newSuite);
        }
        .pushSuite(newSuite);
        //Progress started
        newSuite.setStarted();
        //fire event
        fireOnSuiteStarted(newSuite);
      }
    });
  }
  private SMTestProxy findChildByName(SMTestProxy parentSuiteString fullName) {
    if () {
      for (SMTestProxy proxy : parentSuite.getChildren()) {
        if (fullName.equals(proxy.getName()) && !proxy.isFinal()) {
          return proxy;
        }
      }
    }
    return null;
  }
  public void onTestFinished(@NotNull final TestFinishedEvent testFinishedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final String testName = testFinishedEvent.getName();
        final long duration = testFinishedEvent.getDuration();
        final String fullTestName = getFullTestName(testName);
        final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
        if (testProxy == null) {
          logProblem("Test wasn't started! TestFinished event: name = {" + testName + "}. " +
                     cannotFindFullTestNameMsg(fullTestName));
          return;
        }
        testProxy.setDuration(duration);
        testProxy.setFinished();
        .remove(fullTestName);
        //fire events
        fireOnTestFinished(testProxy);
      }
    });
  }
  public void onSuiteFinished(@NotNull final TestSuiteFinishedEvent suiteFinishedEvent) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final String suiteName = suiteFinishedEvent.getName();
        final SMTestProxy mySuite = .popSuite(suiteName);
        if (mySuite != null) {
          mySuite.setFinished();
          //fire events
          fireOnSuiteFinished(mySuite);
        }
      }
    });
  }
  public void onUncapturedOutput(@NotNull final String textfinal Key outputType) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final SMTestProxy currentProxy = findCurrentTestOrSuite();
        if (ProcessOutputTypes.STDERR.equals(outputType)) {
          currentProxy.addStdErr(text);
        } else if (ProcessOutputTypes.SYSTEM.equals(outputType)) {
          currentProxy.addSystemOutput(text);
        } else {
          currentProxy.addStdOutput(textoutputType);
        }
      }
    });
  }
  public void onError(@NotNull final String localizedMessage,
                      @Nullable final String stackTrace,
                      final boolean isCritical) {
    addToInvokeLater(new Runnable() {
      public void run() {
        final SMTestProxy currentProxy = findCurrentTestOrSuite();
        currentProxy.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() {
        final String testName = testFailedEvent.getName();
        if (testName == null) {
          logProblem("No test name specified in " + testFailedEvent);
          return;
        }
        final String localizedMessage = testFailedEvent.getLocalizedFailureMessage();
        final String stackTrace = testFailedEvent.getStacktrace();
        final boolean isTestError = testFailedEvent.isTestError();
        final String comparisionFailureActualText = testFailedEvent.getComparisonFailureActualText();
        final String comparisionFailureExpectedText = testFailedEvent.getComparisonFailureExpectedText();
        final boolean inDebugMode = SMTestRunnerConnectionUtil.isInDebugMode();
        final String fullTestName = getFullTestName(testName);
        SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
        if (testProxy == null) {
          logProblem("Test wasn't started! TestFailure event: name = {" + testName + "}" +
                             ", message = {" + localizedMessage + "}" +
                             ", stackTrace = {" + stackTrace + "}. " +
                             cannotFindFullTestNameMsg(fullTestName));
          if (inDebugMode) {
            return;
          } else {
            // try to fix the problem:
            if (!.contains(testProxy)) {
              // if hasn't been already reported
              // 1. report
              onTestStarted(new TestStartedEvent(testNamenull));
              // 2. add failure
              testProxy = getProxyByFullTestName(fullTestName);
            }
          }
        }
        if (testProxy == null) {
          return;
        }
        if (comparisionFailureActualText != null && comparisionFailureExpectedText != null) {
          if (.contains(testProxy)) {
            // duplicate message
            logProblem("Duplicate failure for test [" + fullTestName + "]: msg = " + localizedMessage + ", stacktrace = " + stackTrace);
            if (inDebugMode) {
              return;
            }
          }
          testProxy.setTestComparisonFailed(localizedMessagestackTrace,
                                            comparisionFailureActualTextcomparisionFailureExpectedTexttestFailedEvent.getFilePath());
        } else if (comparisionFailureActualText == null && comparisionFailureExpectedText == null) {
          testProxy.setTestFailed(localizedMessagestackTraceisTestError);
        } else {
          logProblem("Comparison failure actual and expected texts should be both null or not null.\n"
                     + "Expected:\n"
                     + comparisionFailureExpectedText + "\n"
                     + "Actual:\n"
                     + comparisionFailureActualText);
        }
        .add(testProxy);
        // fire event
        fireOnTestFailed(testProxy);
      }
    });
  }
  public void onTestIgnored(@NotNull final TestIgnoredEvent testIgnoredEvent) {
     addToInvokeLater(new Runnable() {
      public void run() {
        final String testName = ObjectUtils.assertNotNull(testIgnoredEvent.getName());
        String ignoreComment = testIgnoredEvent.getIgnoreComment();
        final String stackTrace = testIgnoredEvent.getStacktrace();
        final String fullTestName = getFullTestName(testName);
        SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
        if (testProxy == null) {
          final boolean debugMode = SMTestRunnerConnectionUtil.isInDebugMode();
          logProblem("Test wasn't started! " +
                     "TestIgnored event: name = {" + testName + "}, " +
                     "message = {" + ignoreComment + "}. " +
                     cannotFindFullTestNameMsg(fullTestName));
          if (debugMode) {
            return;
          } else {
            // try to fix
            // 1. report test opened
            onTestStarted(new TestStartedEvent(testNamenull));
            // 2. report failure
            testProxy = getProxyByFullTestName(fullTestName);
          }
        }
        if (testProxy == null) {
          return;
        }
        testProxy.setTestIgnored(ignoreCommentstackTrace);
        // fire event
        fireOnTestIgnored(testProxy);
      }
    });
  }
  public void onTestOutput(@NotNull final TestOutputEvent testOutputEvent) {
     addToInvokeLater(new Runnable() {
      public void run() {
        final String testName = testOutputEvent.getName();
        final String text = testOutputEvent.getText();
        final boolean stdOut = testOutputEvent.isStdOut();
        final String fullTestName = getFullTestName(testName);
        final SMTestProxy testProxy = getProxyByFullTestName(fullTestName);
        if (testProxy == null) {
          logProblem("Test wasn't started! TestOutput event: name = {" + testName + "}, " +
                     "isStdOut = " + stdOut + ", " +
                     "text = {" + text + "}. " +
                     cannotFindFullTestNameMsg(fullTestName));
          return;
        }
        if (stdOut) {
          testProxy.addStdOutput(text, ProcessOutputTypes.STDOUT);
        } else {
          testProxy.addStdErr(text);
        }
      }
    });
  }
  public void onTestsCountInSuite(final int count) {
     addToInvokeLater(new Runnable() {
       public void run() {
         fireOnTestsCountInSuite(count);
       }
     });
  }
  @NotNull
  protected final SMTestProxy getCurrentSuite() {
    final SMTestProxy currentSuite = .getCurrentSuite();
    if (currentSuite != null) {
      return currentSuite;
    }
    // current suite shouldn't be null otherwise test runner isn't correct
    // or may be we are in debug mode
    logProblem("Current suite is undefined. Root suite will be used.");
    return ;
  }
 
  protected String getFullTestName(final String testName) {
    // Test name should be unique
    return testName;
  }
  protected int getRunningTestsQuantity() {
  }
  protected Set<AbstractTestProxy> getFailedTestsSet() {
    return Collections.unmodifiableSet();
  }
  @Nullable
  protected SMTestProxy getProxyByFullTestName(final String fullTestName) {
    return .get(fullTestName);
  }
  @TestOnly
  protected void clearInternalSuitesStack() {
  }
  private String cannotFindFullTestNameMsg(String fullTestName) {
    return "Cant find running test for ["
              + fullTestName
              + "]. Current running tests: {"
              + dumpRunningTestsNames() + "}";
  }
    final Set<Stringnames = .keySet();
    final StringBuilder namesDump = new StringBuilder();
    for (String name : names) {
      namesDump.append('[').append(name).append(']').append(',');
    }
    return namesDump;
  }
  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 fireOnSuiteTreeNodeAdded(SMTestProxy testProxy) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onSuiteTreeNodeAdded(testProxy);
    }
  }
  private void fireOnSuiteTreeStarted(SMTestProxy suite) {
    for (SMTRunnerEventsListener listener : ) {
      listener.onSuiteTreeStarted(suite);
    }
  }
  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()) {
          final Application application = ApplicationManager.getApplication();
          if (!application.isHeadlessEnvironment() && !application.isUnitTestMode()) {
            logProblem("Not all events were processed! " + dumpRunningTestsNames());
          }
        }
        .clear();
      }
    });
  }
    //if we can locate test - we will send output to it, otherwise to current test suite
    final SMTestProxy currentProxy;
    if (.size() == 1) {
      //current test
      currentProxy = .values().iterator().next();
    } else {
      //current suite
      //
      // ProcessHandler can fire output available event before processStarted event
      currentProxy = .isEmpty() ?  : getCurrentSuite();
    }
    return currentProxy;
  }
  public static String getTFrameworkPrefix(final String testFrameworkName) {
    return "[" + testFrameworkName + "]: ";
  }
  private void logProblem(final String msg) {
  }
  public static void logProblem(final Logger logfinal String msgfinal String testFrameworkName) {
    logProblem(logmsg, SMTestRunnerConnectionUtil.isInDebugMode(), testFrameworkName);
  }
  public static void logProblem(final Logger logfinal String msgboolean throwErrorfinal String testFrameworkName) {
    final String text = getTFrameworkPrefix(testFrameworkName) + msg;
    if (throwError) {
      log.error(text);
    }
    else {
      log.warn(text);
    }
  }
New to GrepCode? Check out our FAQ X