plugins/gradle/tooling-extension-impl/src/org/jetbrains/plugins/gradle/tooling/internal/init/testFilterInit.gradle

/*
 * Copyright 2000-2014 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.
 */

String[] ijTestIncludes = ${TEST_NAME_INCLUDES}
boolean ijTestFilteringSupported = GradleVersion.current().compareTo(GradleVersion.version("1.10"))>=0
boolean skipExecution

gradle.addBuildListener(new BuildListener() {
  void	buildFinished(BuildResult result) {
    if(result.failure?.message?.startsWith("Task 'cleanTest' not found in") || result.failure?.message?.startsWith("Task 'test' not found in")) {
      logConfigurationError(
        "Unable to run unit tests",
        "Unable to run unit tests, since there is no 'test' task configured in the project." +
        "\n<br>You can add the following into the project gradle script: apply plugin: 'java'" +
        "\n<br><br>See <a href='http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.testing.Test.html'>Gradle Test task</a> for details",
        false
      )
    }
  }
  void	buildStarted(Gradle gradle){}
  void	projectsEvaluated(Gradle gradle){}
  void	projectsLoaded(Gradle gradle){}
  void	settingsEvaluated(Settings settings){}
})

for (incl in ijTestIncludes) {
  if(incl != '*' && !ijTestFilteringSupported)  {
    skipExecution = true
    logConfigurationError(
      "Unable to configure test filtering",
      "Unable to configure test filtering for " + GradleVersion.current() +".<br>Please, use Gradle 1.10 or above or run all tests of a module.",
      true)
    break;
  }
}

gradle.taskGraph.beforeTask { Task task ->
  task.onlyIf { !skipExecution }

  if (task instanceof Test) {
    try {
      logTestReportLocation(task.reports?.html?.entryPoint?.path)

      task.beforeSuite { descriptor ->
        logTestEvent("beforeSuite", descriptor, null, null)
      }
      task.afterSuite { descriptor, result ->
        logTestEvent("afterSuite", descriptor, null, result)
      }

      task.beforeTest { descriptor ->
        logTestEvent("beforeTest", descriptor, null, null)
      }
      task.onOutput { descriptor, event ->
        logTestEvent("onOutput", descriptor, event, null)
      }
      task.afterTest { descriptor, result ->
        logTestEvent("afterTest", descriptor, null, result)
      }

      if(ijTestFilteringSupported) {
        task.filter {
          ijTestIncludes.each(){ includeTestsMatching "${it}" }
        }
      }
    }
    catch (all) {
      logger.error("", all)
    }
  }
}

Object logTestEvent(def testEventType, def testDescriptor, def testEvent, def testResult) {
  def writer = new StringWriter()
  def xml = new groovy.xml.MarkupBuilder(writer)
  xml.event(type: testEventType){
    test(id: testDescriptor.id, parentId: testDescriptor.parent?.id ?: '') {
      if(testDescriptor){
        descriptor(name: testDescriptor.name ?: '', className: testDescriptor.className ?: '')
      }
      if(testEvent) {
        def message = escapeCdata(testEvent.message)
        event(destination: testEvent.destination){
          xml.mkp.yieldUnescaped("$message")
        }
      }
      if(testResult) {
        def errorMsg = escapeCdata(testResult.exception?.message?:'')
        def stackTrace = escapeCdata(getStackTrace(testResult.exception))
        result(resultType: testResult.resultType ?: '', startTime: testResult.startTime, endTime: testResult.endTime){
          if(testResult.exception?.message?.trim()) xml.mkp.yieldUnescaped("<errorMsg>$errorMsg</errorMsg>")
          if(testResult.exception) xml.mkp.yieldUnescaped("<stackTrace>$stackTrace</stackTrace>")

          if('junit.framework.ComparisonFailure'.equals(testResult.exception?.class?.name) ||
             'org.junit.ComparisonFailure'.equals(testResult.exception?.class?.name)) {
            def expected = escapeCdata(testResult.exception.fExpected)
            def actual = escapeCdata(testResult.exception.fActual)
            failureType('comparison')
            xml.mkp.yieldUnescaped("<expected>$expected</expected>")
            xml.mkp.yieldUnescaped("<actual>$actual</actual>")
          } else if('junit.framework.AssertionFailedError'.equals(testResult.exception?.class?.name) ||
                    testResult.exception instanceof AssertionError) {
            failureType('assertionFailed')
          } else {
            failureType('error')
          }
        }
      }
    }
  }

  writeLog(writer.toString())
}

def logTestReportLocation(def report) {
  if(!report) return
  def writer = new StringWriter()
  def xml = new groovy.xml.MarkupBuilder(writer)
  xml.event(type: 'reportLocation', testReport: report)
  writeLog(writer.toString());
}

def logConfigurationError(aTitle, aMessage, boolean openSettings) {
  def writer = new StringWriter()
  def xml = new groovy.xml.MarkupBuilder(writer)
  xml.event(type: 'configurationError', openSettings: openSettings) {
    title(aTitle)
    message(aMessage)
  }
  writeLog(writer.toString());
}

String escapeCdata(String s) {
  return "<![CDATA[" + s?.replaceAll("]]>", "]]]]><![CDATA[>")+ "]]>";
}
def getStackTrace(Throwable t) {
  if(!t) return ''
  StringWriter sw = new StringWriter()
  t.printStackTrace(new PrintWriter(sw))
  sw.toString()
}

def wrap(String s) {
  if(!s) return s;
  s.replaceAll("\r\n|\n\r|\n|\r","<ijLogEol/>\n")
}

def writeLog(s) {
  println String.format("\n<ijLog>%s</ijLog>", wrap(s))
}