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.Location;
 import  com.intellij.execution.testframework.*;
 import  com.intellij.execution.testframework.stacktrace.DiffHyperlink;
 import  com.intellij.execution.ui.ConsoleViewContentType;
 import  com.intellij.ide.util.EditSourceUtil;
 import  com.intellij.openapi.application.ApplicationManager;
 import  com.intellij.openapi.diagnostic.Logger;
 import  com.intellij.openapi.project.DumbService;
 import  com.intellij.openapi.project.PossiblyDumbAware;
 import  com.intellij.openapi.project.Project;
 import  com.intellij.openapi.util.Key;
 import  com.intellij.openapi.util.text.StringUtil;
 import  com.intellij.openapi.vfs.VirtualFileManager;
 import  com.intellij.pom.Navigatable;
 import  com.intellij.psi.search.GlobalSearchScope;
 import  com.intellij.testIntegration.TestLocationProvider;
 import  com.intellij.util.containers.ContainerUtil;
 import  com.intellij.util.containers.ContainerUtilRt;
 import  org.jetbrains.annotations.NotNull;
 import  org.jetbrains.annotations.Nullable;
 
 import java.util.List;

Represents a test result tree node. Not thread-safe. All methods should be called in EDT only.

Author(s):
Roman Chernyatchik
 
 public class SMTestProxy extends AbstractTestProxy {
   private static final Logger LOG = Logger.getInstance(SMTestProxy.class.getName());
 
   private final String myName;
   private final boolean myIsSuite;
   private final String myLocationUrl;
   private final boolean myPreservePresentableName;
 
   private List<SMTestProxymyChildren;
   private SMTestProxy myParent;
 
   private AbstractState myState = NotRunState.getInstance();
   private Long myDuration = null// duration is unknown
   private boolean myDurationIsCached = false// is used for separating unknown and unset duration
   private boolean myHasCriticalErrors = false;
   private boolean myHasErrorsCached = false;
   private boolean myHasPassedTests = false;
   private boolean myHasPassedTestsCached = false;
 
   private String myStacktrace;
 
   private boolean myIsEmptyIsCached = false// is used for separating unknown and unset values
   private boolean myIsEmpty = true;
   private SMTestLocator myLocator = null;
   private Printer myPreferredPrinter = null;
   private String myPresentableName;
   private boolean myConfig = false;
 
   public SMTestProxy(String testNameboolean isSuite, @Nullable String locationUrl) {
     this(testNameisSuitelocationUrlfalse);
   }
 
   public SMTestProxy(String testNameboolean isSuite, @Nullable String locationUrlboolean preservePresentableName) {
      = testName;
      = isSuite;
      = locationUrl;
      = preservePresentableName;
   }
 
   public void setLocator(@NotNull SMTestLocator testLocator) {
      = testLocator;
   }
 
   public void setConfig(boolean config) {
      = config;
   }

  

Deprecated:
use setLocator(SMTestLocator) (to be removed in IDEA 16)
  @SuppressWarnings("deprecation")
  public void setLocator(@NotNull final TestLocationProvider locator) {
    class Adapter implements SMTestLocator, PossiblyDumbAware {
      @NotNull
      @Override
      public List<Location> getLocation(@NotNull String protocol, @NotNull String path, @NotNull Project project, @NotNull GlobalSearchScope scope) {
        return locator.getLocation(protocolpathproject);
      }
      @Override
      public boolean isDumbAware() {
        return DumbService.isDumbAware(locator);
      }
    }
     = new Adapter();
  }
  public void setPreferredPrinter(@NotNull Printer preferredPrinter) {
     = preferredPrinter;
  }
  public boolean isInProgress() {
    return .isInProgress();
  }
  public boolean isDefect() {
    return .isDefect();
  }
  public boolean shouldRun() {
    return true;
  }
  public int getMagnitude() {
    // Is used by some of Tests Filters
    //WARN: It is Hack, see PoolOfTestStates, API is necessary
    return getMagnitudeInfo().getValue();
  }
    return .getMagnitude();
  }
  public boolean hasErrors() {
    // if already cached
    if () {
      return ;
    }
    final boolean canCacheErrors = !.isInProgress();
    // calculate
    final boolean hasErrors = calcHasErrors();
    if (canCacheErrors || hasErrors) {
       = hasErrors;
       = true;
    }
    return hasErrors;
  }
  private boolean calcHasErrors() {
    if () {
      return true;
    }
    for (SMTestProxy child : getChildren()) {
      if (child.hasErrors()) {
        return true;
      }
    }
    return false;
  }

  

Returns:
true if the state is final (PASSED, FAILED, IGNORED, TERMINATED)
  public boolean isFinal() {
    return .isFinal();
  }
  private void setStacktraceIfNotSet(@Nullable String stacktrace) {
    if ( == null = stacktrace;
  }
  public boolean isLeaf() {
    return  == null || .isEmpty();
  }
  public boolean hasPassedTests() {
    if () {
      return ;
    }
    boolean hasPassedTests = calcPassedTests();
    boolean canCache = !.isInProgress();
    if (canCache) {
       = hasPassedTests;
       = true;
    }
    return hasPassedTests;
  }
  public boolean isInterrupted() {
    return .wasTerminated();
  }
  private boolean calcPassedTests() {
    if (isPassed()) {
      return true;
    }
    for (SMTestProxy child : getChildren()) {
      if (child.hasPassedTests()) {
        return true;
      }
    }
    return false;
  }
  public boolean isIgnored() {
  }
  public boolean isPassed() {
  }
  public void addChild(@NotNull SMTestProxy child) {
    ApplicationManager.getApplication().assertIsDispatchThread();
    if ( == null) {
       = ContainerUtil.newArrayListWithCapacity(4);
    }
    .add(child);
    // add printable
    //
    // add link to child's future output in correct place
    // actually if after this suite will obtain output
    // it will place it after this child and before future child
    addLast(child);
    // add child
    //
    //TODO reset children cache
    child.setParent(this);
    // if parent is being printed then all childs output
    // should be also send to the same printer
    child.setPrinter(myPrinter);
    if ( != null && child.myPreferredPrinter == null) {
    }
  }
  @Nullable
  private Printer getRightPrinter(@Nullable Printer printer) {
    if ( != null && printer != null) {
      return ;
    }
    return printer;
  }
  public void setPrinter(Printer printer) {
    super.setPrinter(getRightPrinter(printer));
  }
  public String getName() {
    return ;
  }
  public boolean isConfig() {
    return ;
  }
  @Nullable
  public Location getLocation(@NotNull Project project, @NotNull GlobalSearchScope searchScope) {
    //determines location of test proxy
    final String locationUrl = ;
    return getLocation(projectsearchScopelocationUrl);
  }
  protected Location getLocation(@NotNull Project project, @NotNull GlobalSearchScope searchScopeString locationUrl) {
    if (locationUrl != null &&  != null) {
      String protocolId = VirtualFileManager.extractProtocol(locationUrl);
      if (protocolId != null) {
        String path = VirtualFileManager.extractPath(locationUrl);
        if (!DumbService.isDumb(project) || DumbService.isDumbAware()) {
          List<Location> locations = .getLocation(protocolIdpathprojectsearchScope);
          if (!locations.isEmpty()) {
            return locations.get(0);
          }
        }
      }
    }
    return null;
  }
  @Nullable
  public Navigatable getDescriptor(@Nullable Location location, @NotNull TestConsoleProperties properties) {
    // by location gets navigatable element.
    // It can be file or place in file (e.g. when OPEN_FAILURE_LINE is enabled)
    if (location == nullreturn null;
    String stacktrace = ;
    if (stacktrace != null && properties instanceof SMStacktraceParser && isLeaf()) {
      Navigatable result = properties instanceof SMStacktraceParserEx ?
                           ((SMStacktraceParserEx)properties).getErrorNavigatable(locationstacktrace) :
                             ((SMStacktraceParser)properties).getErrorNavigatable(location.getProject(), stacktrace);
      if (result != null) {
        return result;
      }
    }
    return EditSourceUtil.getDescriptor(location.getPsiElement());
  }
  public boolean isSuite() {
    return ;
  }
  public SMTestProxy getParent() {
    return ;
  }
  public List<? extends SMTestProxygetChildren() {
    return  != null ?  : Collections.<SMTestProxy>emptyList();
  }
  public List<SMTestProxygetAllTests() {
    final List<SMTestProxyallTests = new ArrayList<SMTestProxy>();
    allTests.add(this);
    for (SMTestProxy child : getChildren()) {
      allTests.addAll(child.getAllTests());
    }
    return allTests;
  }
  public void setStarted() {
  }

  
Calculates and caches duration of test or suite

Returns:
null if duration is unknown, otherwise duration value in milliseconds;
  @Nullable
  public Long getDuration() {
    // Returns duration value for tests
    // or cached duration for suites
    if ( || !isSuite()) {
      return ;
    }
    //For suites counts and caches durations of its children. Also it evaluates partial duration,
    //i.e. if duration is unknown it will be ignored in summary value.
    //If duration for all children is unknown summary duration will be also unknown
    //if one of children is ignored - it's duration will be 0 and if child wasn't run,
    //then it's duration will be unknown
     = true;
    return ;
  }
  @Nullable
  public String getDurationString(TestConsoleProperties consoleProperties) {
    switch (getMagnitudeInfo()) {
      case :
      case :
        return !isSubjectToHide(consoleProperties) ? getDurationString() : null;
      case :
      case :
      case :
      case :
      case :
      case :
        return getDurationString();
      default:
        return null;
    }
  }
  private boolean isSubjectToHide(TestConsoleProperties consoleProperties) {
    return TestConsoleProperties.HIDE_PASSED_TESTS.value(consoleProperties) && getParent() != null && !isDefect();
  }
  private String getDurationString() {
    final Long duration = getDuration();
    return duration != null ? StringUtil.formatDuration(duration.longValue()) : null;
  }
  public boolean shouldSkipRootNodeForExport() {
    return true;
  }

  
Sets duration of test

Parameters:
duration In milliseconds
  public void setDuration(final long duration) {
    if (!isSuite()) {
       = true;
       = (duration >= 0) ? duration : null;
      return;
    }
    // Not allow to directly set duration for suites.
    // It should be the sum of children. This requirement is only
    // for safety of current model and may be changed
    .warn("Unsupported operation");
  }
  public void setFinished() {
    if (.isFinal()) {
      // we shouldn't fire new printable because final state
      // has been already fired
      return;
    }
    if (!isSuite()) {
      // if isn't in other finished state (ignored, failed or passed)
    }
    else {
      //Test Suite
    }
    // prints final state additional info
  }
  public void setTestFailed(@NotNull String localizedMessage, @Nullable String stackTraceboolean testError) {
    setStacktraceIfNotSet(stackTrace);
    if ( instanceof TestFailedState) {
      ((TestFailedState)).addError(localizedMessagestackTrace, myPrinter);
    }
    else {
       = testError ? new TestErrorState(localizedMessagestackTrace) : new TestFailedState(localizedMessagestackTrace);
    }
  }
  public void setTestComparisonFailed(@NotNull final String localizedMessage,
                                      @Nullable final String stackTrace,
                                      @NotNull final String actualText,
                                      @NotNull final String expectedText) {
    setTestComparisonFailed(localizedMessagestackTraceactualTextexpectedTextnull);
  }
  public void setTestComparisonFailed(@NotNull final String localizedMessage,
                                      @Nullable final String stackTrace,
                                      @NotNull final String actualText,
                                      @NotNull final String expectedText,
                                      @Nullable final String filePath) {
    setStacktraceIfNotSet(stackTrace);
     = new TestComparisionFailedState(localizedMessagestackTraceactualTextexpectedTextfilePath);
  }
  public void setTestIgnored(@Nullable String ignoreComment, @Nullable String stackTrace) {
    setStacktraceIfNotSet(stackTrace);
     = new TestIgnoredState(ignoreCommentstackTrace);
  }
  public void setParent(@Nullable final SMTestProxy parent) {
     = parent;
  }
  public List<? extends SMTestProxycollectChildren(@Nullable final Filter<SMTestProxyfilter) {
    return filterChildren(filtercollectChildren());
  }
  public List<? extends SMTestProxycollectChildren() {
    final List<? extends SMTestProxyallChildren = getChildren();
    final List<SMTestProxyresult = ContainerUtilRt.newArrayList();
    result.addAll(allChildren);
    for (SMTestProxy p : allChildren) {
      result.addAll(p.collectChildren());
    }
    return result;
  }
  public List<? extends SMTestProxygetChildren(@Nullable Filter<? super SMTestProxyfilter) {
    return filterChildren(filtergetChildren());
  }
  private static List<? extends SMTestProxyfilterChildren(@Nullable Filter<? super SMTestProxyfilter,
                                                            List<? extends SMTestProxyallChildren) {
    if (filter == Filter.NO_FILTER || filter == null) {
      return allChildren;
    }
    final List<SMTestProxyselectedChildren = new ArrayList<SMTestProxy>();
    for (SMTestProxy child : allChildren) {
      if (filter.shouldAccept(child)) {
        selectedChildren.add(child);
      }
    }
    if ((selectedChildren.isEmpty())) {
      return Collections.<SMTestProxy>emptyList();
    }
    return selectedChildren;
  }
  public boolean wasLaunched() {
    return .wasLaunched();
  }

  
Prints this proxy and all its children on given printer

Parameters:
printer Printer
  public void printOn(final Printer printer) {
    final Printer rightPrinter = getRightPrinter(printer);
    super.printOn(rightPrinter);
    final AbstractState oldState = ;
    invokeInAlarm(new Runnable() {
      @Override
      public void run() {
        //Tests State, that provide and formats additional output
        oldState.printOn(rightPrinter);
      }
    });
  }
  public void addStdOutput(final String outputfinal Key outputType) {
    addLast(new Printable() {
      public void printOn(final Printer printer) {
        printer.print(output, ConsoleViewContentType.getConsoleViewType(outputType));
      }
    });
  }
  public void addStdErr(final String output) {
    addLast(new Printable() {
      public void printOn(final Printer printer) {
        printer.print(output, ConsoleViewContentType.ERROR_OUTPUT);
      }
    });
  }

  
This method was left for backward compatibility.

Deprecated:
use SMTestProxy.addError(String output, String stackTrace, boolean isCritical)
Parameters:
output
stackTrace
  public void addError(String output, @Nullable String stackTrace) {
    addError(outputstackTracetrue);
  }
  public void addError(final String output, @Nullable final String stackTraceboolean isCritical) {
     = isCritical;
    setStacktraceIfNotSet(stackTrace);
    addLast(new Printable() {
      public void printOn(final Printer printer) {
        String errorText = TestFailedState.buildErrorPresentationText(outputstackTrace);
        .assertTrue(errorText != null);
        TestFailedState.printError(printer, Collections.singletonList(errorText));
      }
    });
  }
  public void addSystemOutput(final String output) {
    addLast(new Printable() {
      public void printOn(final Printer printer) {
        printer.print(output, ConsoleViewContentType.SYSTEM_OUTPUT);
      }
    });
  }
  @NotNull
  public String getPresentableName() {
    if ( == null) {
      if () {
         = TestsPresentationUtil.getPresentableNameTrimmedOnly(this);
      } else {
         = TestsPresentationUtil.getPresentableName(this);
      }
    }
    return ;
  }
  @Nullable
  public DiffHyperlink getDiffViewerProvider() {
    if ( instanceof TestComparisionFailedState) {
    }
    if ( != null) {
      for (SMTestProxy child : ) {
        if (!child.isDefect()) continue;
        final DiffHyperlink provider = child.getDiffViewerProvider();
        if (provider != null) {
          return provider;
        }
      }
    }
    return null;
  }
  public String toString() {
    return getPresentableName();
  }

  
Process was terminated
  public void setTerminated() {
    if (.isFinal()) {
      return;
    }
    final List<? extends SMTestProxychildren = getChildren();
    for (SMTestProxy child : children) {
      child.setTerminated();
    }
  }
  public boolean wasTerminated() {
    return .wasTerminated();
  }
  @Nullable
  public String getLocationUrl() {
    return ;
  }

  
Check if suite contains error tests or suites

Returns:
True if contains
  private boolean containsErrorTests() {
    final List<? extends SMTestProxychildren = getChildren();
    for (SMTestProxy child : children) {
      if (child.getMagnitudeInfo() == ..) {
        return true;
      }
    }
    return false;
  }
  private boolean containsFailedTests() {
    final List<? extends SMTestProxychildren = getChildren();
    for (SMTestProxy child : children) {
      if (child.getMagnitudeInfo() == ..) {
        return true;
      }
    }
    return false;
  }

  
Determines site state after it has been finished

Returns:
New state
    final AbstractState state;
    if (isLeaf()) {
    }
    else if (isEmptySuite()) {
      state = .;
    }
    else {
      if (isDefect()) {
        // Test suit contains errors if at least one of its tests contains error
        if (containsErrorTests()) {
          state = .;
        }
        else {
          // if suite contains failed tests - all suite should be
          // consider as failed
          state = containsFailedTests()
                  ? .
                  : .;
        }
      }
      else {
        state = .;
      }
    }
    return state;
  }
  public boolean isEmptySuite() {
    if () {
      return ;
    }
    if (!isSuite()) {
      // test - no matter what we will return
       = true;
       = true;
      return true;
    }
     = true;
    final List<? extends SMTestProxyallTestCases = getChildren();
    for (SMTestProxy testOrSuite : allTestCases) {
      if (testOrSuite.isSuite()) {
        // suite
        if (!testOrSuite.isEmptySuite()) {
          // => parent suite isn't empty
           = false;
           = true;
          break;
        }
        // all suites are empty
         = true;
        // we can cache only final state, otherwise test may be added
         = .isFinal();
      }
      else {
        // test => parent suite isn't empty
         = false;
         = true;
        break;
      }
    }
    return ;
  }
  @Nullable
  private Long calcSuiteDuration() {
    long partialDuration = 0;
    boolean durationOfChildrenIsUnknown = true;
    for (SMTestProxy child : getChildren()) {
      final Long duration = child.getDuration();
      if (duration != null) {
        durationOfChildrenIsUnknown = false;
        partialDuration += duration.longValue();
      }
    }
    // Lets convert partial duration in integer object. Negative partial duration
    // means that duration of all children is unknown
    return durationOfChildrenIsUnknown ? null : partialDuration;
  }

  
Recursively invalidates cached duration for container(parent) suites
    // Invalidates duration of this suite
     = null;
     = false;
    // Invalidates duration of container suite
    final SMTestProxy containerSuite = getParent();
    if (containerSuite != null) {
      containerSuite.invalidateCachedDurationForContainerSuites();
    }
  }
  public static class SMRootTestProxy extends SMTestProxy implements TestProxyRoot {
    private boolean myTestsReporterAttached// false by default
    private String myPresentation;
    private String myComment;
    private String myRootLocationUrl;
    public SMRootTestProxy() {
      super("[root]"truenull);
    }
    public void setTestsReporterAttached() {
       = true;
    }
    public boolean isTestsReporterAttached() {
      return ;
    }
    @Override
    public String getPresentation() {
      return ;
    }
    public void setPresentation(String presentation) {
       = presentation;
    }
    public void setComment(String comment) {
       = comment;
    }
    @Override
    public String getComment() {
      return ;
    }
    public void setRootLocationUrl(String locationUrl) {
       = locationUrl;
    }
    @Override
    public String getRootLocation() {
      return ;
    }
    @Nullable
    @Override
    public Location getLocation(@NotNull Project project, @NotNull GlobalSearchScope searchScope) {
      return  != null ? super.getLocation(projectsearchScope
                                       : super.getLocation(projectsearchScope);
    }
    @Override
      if (isLeaf() && !isTestsReporterAttached()) {
      }
      return super.determineSuiteStateOnFinished();
    }
  }
New to GrepCode? Check out our FAQ X