public boolean parse()

in agent/src/jetbrains/buildServer/xmlReportPlugin/parsers/antJUnit/AntJUnitReportParser.java [47:179]
118 lines of code
31 McCabe index (conditional complexity)

  public boolean parse(@NotNull final File file, @Nullable final ParsingResult prevResult) throws ParsingException {
    if (prevResult != null) {
      myTestsToSkip = ((TestParsingResult) prevResult).getTests();
    }
    try {
      new AntJUnitXmlReportParser(new AntJUnitXmlReportParser.Callback() {

        @Override
        public void suiteFound(@Nullable final String suiteName) {
          if (suiteName == null) {
            myTestReporter.warning(TestMessages.getFileContainsUnnamedMessage(file, "suite"));
            return;
          }

          myTestReporter.openTestSuite(suiteName);
          ++myLoggedSuites;
          mySuites.push(suiteName);
        }

        @Override
        public void suiteFailureFound(@Nullable final String suiteName,
                                      @Nullable final String type,
                                      @Nullable final String message,
                                      @Nullable final String trace) {
          if (mySuites.isEmpty() || !mySuites.peek().equals(suiteName)) {
            LOG.warn(TestMessages.getFailedToLogSuiteMessage("failure", suiteName));
            return;
          }
          myTestReporter.error(TestMessages.getOutFromSuiteMessage("Failure", suiteName, type, message, trace));
        }

        @Override
        public void suiteErrorFound(@Nullable final String suiteName,
                                    @Nullable final String type,
                                    @Nullable final String message,
                                    @Nullable final String trace) {
          if (mySuites.isEmpty() || !mySuites.peek().equals(suiteName)) {
            LOG.warn(TestMessages.getFailedToLogSuiteMessage("error", suiteName));
            return;
          }
          myTestReporter.error(TestMessages.getOutFromSuiteMessage("Error", suiteName, type, message, trace));
        }

        @Override
        public void suiteSystemOutFound(@Nullable final String suiteName, @Nullable final String message) {
          if (mySuites.isEmpty() || !mySuites.peek().equals(suiteName)) {
            LOG.warn(TestMessages.getFailedToLogSuiteMessage("system out", suiteName));
            return;
          }
          if (message != null && message.length() > 0) {
            myTestReporter.info(TestMessages.getOutFromSuiteMessage("System out", suiteName, message));
          }
        }

        @Override
        public void suiteSystemErrFound(@Nullable final String suiteName, @Nullable final String message) {
          if (mySuites.isEmpty() || !mySuites.peek().equals(suiteName)) {
            LOG.warn(TestMessages.getFailedToLogSuiteMessage("system err", suiteName));
            return;
          }
          if (message != null && message.length() > 0) {
            final String msg = TestMessages.getOutFromSuiteMessage("System error", suiteName, message);
            if (myLogInternalSystemError) {
              myTestReporter.info(msg);
            } else {
              myTestReporter.warning(msg);
            }
          }
        }

        @Override
        public void suiteFinished(@Nullable final String suiteName) {
          if (mySuites.isEmpty() || !mySuites.peek().equals(suiteName)) {
            LOG.warn(TestMessages.getFailedToLogSuiteMessage("finish", suiteName));
            return;
          }
          myTestReporter.closeTestSuite();
          mySuites.pop();
        }

        @Override
        public void testFound(@NotNull TestData testData) {
          try {
            if (testSkipped()) return;

            final String testName = testData.getName();

            if (testName == null) {
              myTestReporter.warning(TestMessages.getFileContainsUnnamedMessage(file, "test"));
              return;
            }

            myTestReporter.openTest(testName);
            if (!testData.isExecuted()) myTestReporter.testIgnored("");
            if (testData.getStdOut() != null && testData.getStdOut().length() > 0) {
              myTestReporter.testStdOutput(testData.getStdOut());
            }
            if (testData.getStdErr() != null && testData.getStdErr().length() > 0) {
              if (myLogInternalSystemError) {
                myTestReporter.info(testData.getStdErr());
              } else {
                myTestReporter.testErrOutput(testData.getStdErr());
              }
            }
            if (testData.getFailureType() != null || testData.getFailureMessage() != null || testData.getFailureStackTrace() != null) {
              myTestReporter
                .testFail(TestMessages.getFailureMessage(testData.getFailureType(), testData.getFailureMessage()), testData.getFailureStackTrace());
            }
            myTestReporter.closeTest(testData.getDuration());
          } finally {
            ++myLoggedTests;
          }
        }

        @Override
        public void unexpectedFormat(@NotNull final String msg) {
          myTestReporter.error(TestMessages.getFileExpectedFormatMessage(file, msg, "Ant JUnit Task"));
        }
      }, myDurationParser).parse(file);
      return true;
    } catch (IOException e) {
      myParsingException = new ParsingException(e);

      while (!mySuites.isEmpty()) {
        myTestReporter.closeTestSuite();
        mySuites.pop();
      }

      LOG.debug(TestMessages.getCouldNotCompletelyParseMessage(file, e, myLoggedTests));
    }

    return false;
  }