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.TestConsoleProperties;
 import  com.intellij.openapi.diagnostic.Logger;
 import  com.intellij.openapi.util.Key;
 import  com.intellij.openapi.util.text.StringUtil;
 import  jetbrains.buildServer.messages.serviceMessages.*;
 import  org.jetbrains.annotations.NonNls;
 import  org.jetbrains.annotations.NotNull;
 import  org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
 
 import static com.intellij.execution.testframework.sm.runner.GeneralToSMTRunnerEventsConvertor.getTFrameworkPrefix;

This implementation also supports messages split in parts by early flush. Implementation assumes that buffer is being flushed on line end or by timer, i.e. incoming text contains no more than one line's end marker ('\r', '\n', or "\r\n") (e.g. process was run with IDEA program's runner)

Author(s):
Roman Chernyatchik
 
   private static final Logger LOG = Logger.getInstance(OutputToGeneralTestEventsConverter.class.getName());
 
   private final String myTestFrameworkName;
   private final OutputLineSplitter mySplitter;
 
   private boolean myPendingLineBreakFlag;
 
   public OutputToGeneralTestEventsConverter(@NotNull String testFrameworkName, @NotNull TestConsoleProperties consoleProperties) {
      = testFrameworkName;
      = new OutputLineSplitter(consoleProperties.isEditable()) {
       @Override
       protected void onLineAvailable(@NotNull String text, @NotNull Key outputTypeboolean tcLikeFakeOutput) {
         processConsistentText(textoutputTypetcLikeFakeOutput);
       }
     };
   }
 
   public void setProcessor(@Nullable final GeneralTestEventsProcessor processor) {
      = processor;
   }
 
     return ;
   }
 
   public void dispose() {
     setProcessor(null);
   }
 
   public void process(final String textfinal Key outputType) {
     .process(textoutputType);
   }

  
Flashes the rest of stdout text buffer after output has been stopped
 
   public void flushBufferBeforeTerminating() {
     .flush();
     if () {
     }
   }
 
   private void fireOnUncapturedLineBreak() {
     fireOnUncapturedOutput("\n", ProcessOutputTypes.STDOUT);
   }
 
   private void processConsistentText(final String textfinal Key outputTypeboolean tcLikeFakeOutput) {
     try {
       if (!processServiceMessages(textoutputType)) {
         if () {
           // output type for line break isn't important
           // we may use any, e.g. current one
           fireOnUncapturedLineBreak();
           = false;
        }
        // Filters \n
        String outputToProcess = text;
        if (tcLikeFakeOutput && text.endsWith("\n")) {
          // ServiceMessages protocol requires that every message
          // should start with new line, so such behaviour may led to generating
          // some number of useless \n.
          //
          // IDEA process handler flush output by size or line break
          // So:
          //  1. "a\n\nb\n" -> ["a\n", "\n", "b\n"]
          //  2. "a\n##teamcity[..]\n" -> ["a\n", "#teamcity[..]\n"]
          // We need distinguish 1) and 2) cases, in 2) first linebreak is redundant and must be ignored
          // in 2) linebreak must be considered as output
          // output will be in TestOutput message
          // Lets set myPendingLineBreakFlag if we meet "\n" and then ignore it or apply depending on
          // next output chunk
           = true;
          outputToProcess = outputToProcess.substring(0, outputToProcess.length() - 1);
        }
        //fire current output
        fireOnUncapturedOutput(outputToProcessoutputType);
      }
      else {
         = false;
      }
    }
    catch (ParseException e) {
      .error(getTFrameworkPrefix() + "Error parsing text: [" + text + "]"e);
    }
  }
  protected boolean processServiceMessages(final String text,
                                           final Key outputType,
                                           final ServiceMessageVisitor visitorthrows ParseException {
    // service message parser expects line like "##teamcity[ .... ]" without whitespaces in the end.
    final ServiceMessage message = ServiceMessage.parse(text.trim());
    if (message != null) {
      message.visit(visitor);
    }
    return message != null;
  }
  private void fireOnTestStarted(@NotNull TestStartedEvent testStartedEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestStarted(testStartedEvent);
    }
  }
  private void fireOnTestFailure(@NotNull TestFailedEvent testFailedEvent) {
    assertNotNull(testFailedEvent.getLocalizedFailureMessage());
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestFailure(testFailedEvent);
    }
  }
  private void fireOnTestIgnored(@NotNull TestIgnoredEvent testIgnoredEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestIgnored(testIgnoredEvent);
    }
  }
  private void fireOnTestFinished(@NotNull TestFinishedEvent testFinishedEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestFinished(testFinishedEvent);
    }
  }
  private void fireOnCustomProgressTestsCategory(final String categoryName,
                                                 int testsCount) {
    assertNotNull(categoryName);
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      final boolean disableCustomMode = StringUtil.isEmpty(categoryName);
      processor.onCustomProgressTestsCategory(disableCustomMode ? null : categoryName,
                                              disableCustomMode ? 0 : testsCount);
    }
  }
  private void fireOnCustomProgressTestStarted() {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onCustomProgressTestStarted();
    }
  }
  private void fireOnCustomProgressTestFinished() {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onCustomProgressTestFinished();
    }
  }
  private void fireOnCustomProgressTestFailed() {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onCustomProgressTestFailed();
    }
  }
  private void fireOnTestFrameworkAttached() {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestsReporterAttached();
    }
  }
  private void fireOnSuiteTreeNodeAdded(String testNameString locationHint) {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onSuiteTreeNodeAdded(testNamelocationHint);
    }
  }
  private void fireRootPresentationAdded(String rootName, @Nullable String commentString rootLocation) {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onRootPresentationAdded(rootNamecommentrootLocation);
    }
  }
  private void fireOnSuiteTreeStarted(String suiteNameString locationHint) {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onSuiteTreeStarted(suiteNamelocationHint);
    }
  }
  private void fireOnSuiteTreeEnded(String suiteName) {
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onSuiteTreeEnded(suiteName);
    }
  }
  private void fireOnTestOutput(@NotNull TestOutputEvent testOutputEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestOutput(testOutputEvent);
    }
  }
  private void fireOnUncapturedOutput(final String textfinal Key outputType) {
    assertNotNull(text);
    if (StringUtil.isEmpty(text)) {
      return;
    }
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onUncapturedOutput(textoutputType);
    }
  }
  private void fireOnTestsCountInSuite(final int count) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onTestsCountInSuite(count);
    }
  }
  private void fireOnSuiteStarted(@NotNull TestSuiteStartedEvent suiteStartedEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onSuiteStarted(suiteStartedEvent);
    }
  }
  private void fireOnSuiteFinished(@NotNull TestSuiteFinishedEvent suiteFinishedEvent) {
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onSuiteFinished(suiteFinishedEvent);
    }
  }
  protected void fireOnErrorMsg(final String localizedMessage,
                                @Nullable final String stackTrace,
                                boolean isCritical) {
    assertNotNull(localizedMessage);
    // local variable is used to prevent concurrent modification
    final GeneralTestEventsProcessor processor = ;
    if (processor != null) {
      processor.onError(localizedMessagestackTraceisCritical);
    }
  }
  private void assertNotNull(final String s) {
    if (s == null) {
      .error(getTFrameworkPrefix() + " @NotNull value is expected.");
    }
  }
  public void onStartTesting() {}
  private class MyServiceMessageVisitor extends DefaultServiceMessageVisitor {
    @NonNls public static final String KEY_TESTS_COUNT = "testCount";
    @NonNls private static final String ATTR_KEY_TEST_ERROR = "error";
    @NonNls private static final String ATTR_KEY_TEST_COUNT = "count";
    @NonNls private static final String ATTR_KEY_TEST_DURATION = "duration";
    @NonNls private static final String ATTR_KEY_LOCATION_URL = "locationHint";
    @NonNls private static final String ATTR_KEY_LOCATION_URL_OLD = "location";
    @NonNls private static final String ATTR_KEY_STACKTRACE_DETAILS = "details";
    @NonNls private static final String ATTR_KEY_DIAGNOSTIC = "diagnosticInfo";
    @NonNls private static final String ATTR_KEY_CONFIG = "config";
    @NonNls private static final String MESSAGE = "message";
    @NonNls private static final String TEST_REPORTER_ATTACHED = "enteredTheMatrix";
    @NonNls private static final String SUITE_TREE_STARTED = "suiteTreeStarted";
    @NonNls private static final String SUITE_TREE_ENDED = "suiteTreeEnded";
    @NonNls private static final String SUITE_TREE_NODE = "suiteTreeNode";
    @NonNls private static final String ROOT_PRESENTATION = "rootName";
    @NonNls private static final String ATTR_KEY_STATUS = "status";
    @NonNls private static final String ATTR_VALUE_STATUS_ERROR = "ERROR";
    @NonNls private static final String ATTR_VALUE_STATUS_WARNING = "WARNING";
    @NonNls private static final String ATTR_KEY_TEXT = "text";
    @NonNls private static final String ATTR_KEY_ERROR_DETAILS = "errorDetails";
    @NonNls private static final String ATTR_KEY_EXPECTED_FILE_PATH = "expectedFile";
    @NonNls public static final String CUSTOM_STATUS = "customProgressStatus";
    @NonNls private static final String ATTR_KEY_TEST_TYPE = "type";
    @NonNls private static final String ATTR_KEY_TESTS_CATEGORY = "testsCategory";
    @NonNls private static final String ATTR_VAL_TEST_STARTED = "testStarted";
    @NonNls private static final String ATTR_VAL_TEST_FINISHED = "testFinished";
    @NonNls private static final String ATTR_VAL_TEST_FAILED = "testFailed";
    public void visitTestSuiteStarted(@NotNull final TestSuiteStarted suiteStarted) {
      final String locationUrl = fetchTestLocation(suiteStarted);
      TestSuiteStartedEvent suiteStartedEvent = new TestSuiteStartedEvent(suiteStartedlocationUrl);
      fireOnSuiteStarted(suiteStartedEvent);
    }
    @Nullable
    private String fetchTestLocation(final TestSuiteStarted suiteStarted) {
      final Map<StringStringattrs = suiteStarted.getAttributes();
      final String location = attrs.get();
      if (location == null) {
        // try old API
        final String oldLocation = attrs.get();
        if (oldLocation != null) {
                    +
                    "Test Runner API was changed for TeamCity 5.0 compatibility. Please use 'locationHint' attribute instead of 'location'.");
          return oldLocation;
        }
        return null;
      }
      return location;
    }
    public void visitTestSuiteFinished(@NotNull final TestSuiteFinished suiteFinished) {
      TestSuiteFinishedEvent finishedEvent = new TestSuiteFinishedEvent(suiteFinished);
      fireOnSuiteFinished(finishedEvent);
    }
    public void visitTestStarted(@NotNull final TestStarted testStarted) {
      // TODO
      // final String locationUrl = testStarted.getLocationHint();
      final Map<StringStringattributes = testStarted.getAttributes();
      final String locationUrl = attributes.get();
      TestStartedEvent testStartedEvent = new TestStartedEvent(testStartedlocationUrl);
      testStartedEvent.setConfig(attributes.get() != null);
      fireOnTestStarted(testStartedEvent);
    }
    public void visitTestFinished(@NotNull final TestFinished testFinished) {
      //TODO
      //final Integer duration = testFinished.getTestDuration();
      //fireOnTestFinished(testFinished.getTestName(), duration != null ? duration.intValue() : 0);
      final String durationStr = testFinished.getAttributes().get();
      // Test duration in milliseconds
      long duration = 0;
      if (!StringUtil.isEmptyOrSpaces(durationStr)) {
        duration = convertToLong(durationStrtestFinished);
      }
      TestFinishedEvent testFinishedEvent = new TestFinishedEvent(testFinishedduration);
      fireOnTestFinished(testFinishedEvent);
    }
    public void visitTestIgnored(@NotNull final TestIgnored testIgnored) {
      final String stacktrace = testIgnored.getAttributes().get();
      fireOnTestIgnored(new TestIgnoredEvent(testIgnoredstacktrace));
    }
    public void visitTestStdOut(@NotNull final TestStdOut testStdOut) {
      fireOnTestOutput(new TestOutputEvent(testStdOuttestStdOut.getStdOut(), true));
    }
    public void visitTestStdErr(@NotNull final TestStdErr testStdErr) {
      fireOnTestOutput(new TestOutputEvent(testStdErrtestStdErr.getStdErr(), false));
    }
    public void visitTestFailed(@NotNull final TestFailed testFailed) {
      final Map<StringStringattributes = testFailed.getAttributes();
      final boolean testError = attributes.get() != null;
      TestFailedEvent testFailedEvent = new TestFailedEvent(testFailedtestErrorattributes.get());
      fireOnTestFailure(testFailedEvent);
    }
    public void visitPublishArtifacts(@NotNull final PublishArtifacts publishArtifacts) {
      //Do nothing
    }
    public void visitProgressMessage(@NotNull final ProgressMessage progressMessage) {
      //Do nothing
    }
    public void visitProgressStart(@NotNull final ProgressStart progressStart) {
      //Do nothing
    }
    public void visitProgressFinish(@NotNull final ProgressFinish progressFinish) {
      //Do nothing
    }
    public void visitBuildStatus(@NotNull final BuildStatus buildStatus) {
      //Do nothing
    }
    public void visitBuildNumber(@NotNull final BuildNumber buildNumber) {
      //Do nothing
    }
    public void visitBuildStatisticValue(@NotNull final BuildStatisticValue buildStatsValue) {
      //Do nothing
    }
    @Override
    public void visitMessageWithStatus(@NotNull Message msg) {
      final Map<StringStringmsgAttrs = msg.getAttributes();
      final String text = msgAttrs.get();
      if (!StringUtil.isEmpty(text)) {
        // msg status
        final String status = msgAttrs.get();
        if (status.equals()) {
          // error msg
          final String stackTrace = msgAttrs.get();
          fireOnErrorMsg(textstackTracetrue);
        }
        else if (status.equals()) {
          // warning msg
          // let's show warning via stderr
          final String stackTrace = msgAttrs.get();
          fireOnErrorMsg(textstackTracefalse);
        }
        else {
          // some other text
          // we cannot pass output type here but it is a service message
          // let's think that is was stdout
          fireOnUncapturedOutput(text, ProcessOutputTypes.STDOUT);
        }
      }
    }
    public void visitServiceMessage(@NotNull final ServiceMessage msg) {
      final String name = msg.getMessageName();
      if (.equals(name)) {
        processTestCountInSuite(msg);
      }
      else if (.equals(name)) {
        processCustomStatus(msg);
      }
      else if (.equals(name)) {
        final Map<StringStringmsgAttrs = msg.getAttributes();
        final String text = msgAttrs.get();
        if (!StringUtil.isEmpty(text)) {
          // some other text
          // we cannot pass output type here but it is a service message
          // let's think that is was stdout
          fireOnUncapturedOutput(text, ProcessOutputTypes.STDOUT);
        }
      }
      else if (.equals(name)) {
      }
      else if (.equals(name)) {
        fireOnSuiteTreeStarted(msg.getAttributes().get("name"), msg.getAttributes().get());
      }
      else if (.equals(name)) {
        fireOnSuiteTreeEnded(msg.getAttributes().get("name"));
      }
      else if (.equals(name)) {
        fireOnSuiteTreeNodeAdded(msg.getAttributes().get("name"), msg.getAttributes().get());
      }
      else if (.equals(name)) {
        final Map<StringStringattributes = msg.getAttributes();
        fireRootPresentationAdded(attributes.get("name"), attributes.get("comment"), attributes.get("location"));
      }
      else {
        GeneralToSMTRunnerEventsConvertor.logProblem("Unexpected service message:" + name);
      }
    }
    private void processTestCountInSuite(final ServiceMessage msg) {
      final String countStr = msg.getAttributes().get();
      fireOnTestsCountInSuite(convertToInt(countStrmsg));
    }
    private int convertToInt(String countStrfinal ServiceMessage msg) {
      int count = 0;
      try {
        count = Integer.parseInt(countStr);
      }
      catch (NumberFormatException ex) {
        final String diagnosticInfo = msg.getAttributes().get();
        .error(getTFrameworkPrefix() + "Parse integer error." + (diagnosticInfo == null ? "" : " " + diagnosticInfo),
                  ex);
      }
      return count;
    }
    private long convertToLong(final String countStr, @NotNull final ServiceMessage msg) {
      long count = 0;
      try {
        count = Long.parseLong(countStr);
      }
      catch (NumberFormatException ex) {
        final String diagnosticInfo = msg.getAttributes().get();
        .error(getTFrameworkPrefix() + "Parse long error." + (diagnosticInfo == null ? "" : " " + diagnosticInfo), ex);
      }
      return count;
    }
    private void processCustomStatus(final ServiceMessage msg) {
      final Map<StringStringattrs = msg.getAttributes();
      final String msgType = attrs.get();
      if (msgType != null) {
        if (msgType.equals()) {
          fireOnCustomProgressTestStarted();
        }
        else if (msgType.equals()) {
        }
        else if (msgType.equals()) {
          fireOnCustomProgressTestFailed();
        }
        return;
      }
      final String testsCategory = attrs.get();
      if (testsCategory != null) {
        final String countStr = msg.getAttributes().get();
        fireOnCustomProgressTestsCategory(testsCategoryconvertToInt(countStrmsg));
        //noinspection UnnecessaryReturnStatement
        return;
      }
    }
  }
New to GrepCode? Check out our FAQ X