X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=build.gradle;h=ad7c94f15d6df7c8bae7deb9aefdfe97292fd4a7;hb=19c22459dca6c69d6f1fd0eed029c01e21c99854;hp=2d2dad0e81b15a0c105653924f457123b06aaa1e;hpb=3b59fa4f77a679254cc31c715299d9760a681aad;p=jalview.git

diff --git a/build.gradle b/build.gradle
index 2d2dad0..ad7c94f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1735,9 +1735,24 @@ run.dependsOn compileJava
 compileTestJava.dependsOn compileJava
 
 
-ext.testsFailed = false
+
+test {
+  group = "Verification"
+  description = "Runs all testTaskN tasks)"
+
+  if (useClover) {
+    dependsOn cloverClasses
+  } else { //?
+    dependsOn testClasses
+  }
+
+  // not running tests in this task
+  exclude "**/*"
+}
 /* testTask0 is the main test task */
 task testTask0(type: Test) {
+  group = "Verification"
+  description = "The main test task. Runs all non-testTaskN-labelled tests (unless excluded)"
   useTestNG() {
     includeGroups testng_groups.split(",")
     excludeGroups testng_excluded_groups.split(",")
@@ -1749,15 +1764,30 @@ task testTask0(type: Test) {
 
 /* separated tests */
 task testTask1(type: Test) {
+  group = "Verification"
+  description = "Tests that need to be isolated from the main test run"
   useTestNG() {
     includeGroups name
     excludeGroups testng_excluded_groups.split(",")
-    tasks.withType(Test).matching {it.name.startsWith("testTask") && it.name != name}.all {t -> excludeGroups t.name}
     preserveOrder true
     useDefaultListeners=true
   }
 }
 
+/* insert more testTaskNs here -- change N to next digit or other string */
+/*
+task testTaskN(type: Test) {
+  group = "Verification"
+  description = "Tests that need to be isolated from the main test run"
+  useTestNG() {
+    includeGroups name
+    excludeGroups testng_excluded_groups.split(",")
+    preserveOrder true
+    useDefaultListeners=true
+  }
+}
+*/
+
 /*
  * adapted from https://medium.com/@wasyl/pretty-tests-summary-in-gradle-744804dd676c
  * to summarise test results from all Test tasks
@@ -1766,7 +1796,6 @@ task testTask1(type: Test) {
 import groovy.time.TimeCategory
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
-
 rootProject.ext.testsResults = [] // Container for tests summaries
 
 tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}.all { testTask ->
@@ -1775,7 +1804,7 @@ tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}.all { te
   if (useClover) {
     dependsOn cloverClasses
   } else { //?
-    dependsOn compileJava //?
+    dependsOn testClasses //?
   }
 
   // run main tests first
@@ -1783,44 +1812,30 @@ tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}.all { te
     testTask.mustRunAfter "testTask0"
 
   testTask.testLogging { logging ->
-    events TestLogEvent.FAILED,
-      TestLogEvent.SKIPPED,
-      TestLogEvent.STANDARD_OUT,
-      TestLogEvent.STANDARD_ERROR
+    events TestLogEvent.FAILED
+//      TestLogEvent.SKIPPED,
+//      TestLogEvent.STANDARD_OUT,
+//      TestLogEvent.STANDARD_ERROR
 
     exceptionFormat TestExceptionFormat.FULL
     showExceptions true
     showCauses true
     showStackTraces true
+
+    info.events = [ TestLogEvent.FAILED ]
   }
 
+
+
   ignoreFailures = true // Always try to run all tests for all modules
 
   afterSuite { desc, result ->
+    if (desc.parent)
+      return // Only summarize results for whole modules
 
-    if (desc.parent) return // Only summarize results for whole modules
-
-    String summary = "${testTask.project.name}:${testTask.name} results: ${result.resultType} " +
-      "(" +
-      "${result.testCount} tests, " +
-      "${result.successfulTestCount} successes, " +
-      "${result.failedTestCount} failures, " +
-      "${result.skippedTestCount} skipped" +
-      ") " +
-      "in ${TimeCategory.minus(new Date(result.endTime), new Date(result.startTime))}" +
-      "\n" +
-          "Report file: ${testTask.reports.html.entryPoint}"
-
-    // Add reports in `testsResults`, keep failed suites at the end
-    if (result.resultType == TestResult.ResultType.SUCCESS) {
-      rootProject.ext.testsResults.add(0, summary)
-    } else {
-      rootProject.ext.testsResults += summary
-    }
+    def resultsInfo = [testTask.project.name, testTask.name, result, TimeCategory.minus(new Date(result.endTime), new Date(result.startTime)), testTask.reports.html.entryPoint]
 
-    if (result.resultType == TestResult.ResultType.FAILURE) {
-      testsFailed = true
-    }
+    rootProject.ext.testsResults.add(resultsInfo)
   }
 
   // from original test task
@@ -1842,11 +1857,25 @@ tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}.all { te
   jvmArgs += additional_compiler_args
 
   doFirst {
+    // this is not perfect yet -- we should only add the commandLineIncludePatterns to the
+    // testTasks that include the tests, and exclude all from the others.
+    // get --test argument
+    filter.commandLineIncludePatterns = test.filter.commandLineIncludePatterns
+    // do something with testTask.getCandidateClassFiles() to see if the test should silently finish because of the
+    // commandLineIncludePatterns not matching anything.  Instead we are doing setFailOnNoMatchingTests(false) below
+
+
     if (useClover) {
       println("Running tests " + (useClover?"WITH":"WITHOUT") + " clover")
     }
   }
 
+
+  /* don't fail on no matching tests (so --tests will run across all testTasks) */
+  testTask.filter.setFailOnNoMatchingTests(false)
+
+  /* ensure the "test" task dependsOn all the testTasks */
+  test.dependsOn testTask
 }
 
 gradle.buildFinished {
@@ -1854,47 +1883,117 @@ gradle.buildFinished {
 
     if (!allResults.isEmpty()) {
         printResults allResults
+        allResults.each {r ->
+          if (r[2].resultType == TestResult.ResultType.FAILURE)
+            throw new GradleException("Failed tests!")
+        }
     }
 }
 
-private static void printResults(allResults) {
-    def maxLength = allResults*.readLines().flatten().collect { it.length() }.max()
-
-    println "┌${"${"─" * maxLength}"}┐"
-
-    println allResults.collect {
-        it.readLines().collect {
-            "│" + it + " " * (maxLength - it.length()) + "│"
-        }.join("\n")
-    }.join("\n├${"${"─" * maxLength}"}┤\n")
-
-    println "└${"${"─" * maxLength}"}┘"
+private static String colString(styler, col, colour, text) {
+  return col?"${styler[colour](text)}":text
 }
-/* END of test tasks results summary */
 
-task verifyTestStatus {
-  doLast {
-    if (testsFailed) {
-      throw new GradleException("There were failing tests!")
+private static String getSummaryLine(s, pn, tn, rt, rc, rs, rf, rsk, t, col) {
+  def colour = 'black'
+  def text = rt
+  def nocol = false
+  if (rc == 0) {
+    text = "-----"
+    nocol = true
+  } else {
+    switch(rt) {
+      case TestResult.ResultType.SUCCESS:
+        colour = 'green'
+        break;
+      case TestResult.ResultType.FAILURE:
+        colour = 'red'
+        break;
+      default:
+        nocol = true
+        break;
     }
   }
+  StringBuilder sb = new StringBuilder()
+  sb.append("${pn}")
+  if (tn != null)
+    sb.append(":${tn}")
+  sb.append(" results: ")
+  sb.append(colString(s, col && !nocol, colour, text))
+  sb.append(" (")
+  sb.append("${rc} tests, ")
+  sb.append(colString(s, col && rs > 0, 'green', rs))
+  sb.append(" successes, ")
+  sb.append(colString(s, col && rf > 0, 'red', rf))
+  sb.append(" failures, ")
+  sb.append("${rsk} skipped) in ${t}")
+  return sb.toString()
 }
 
-test {
-  // from original test task
-  if (useClover) {
-    //dependsOn.clear()
-    dependsOn cloverClasses
-  } else { //?
-    dependsOn compileJava //?
-  }
-  dependsOn tasks.withType(Test).matching {t -> t.getName().startsWith("testTask")}
-  finalizedBy verifyTestStatus
+private static void printResults(allResults) {
 
+    // styler from https://stackoverflow.com/a/56139852
+    def styler = 'black red green yellow blue magenta cyan white'.split().toList().withIndex(30).collectEntries { key, val -> [(key) : { "\033[${val}m${it}\033[0m" }] }
+
+    def maxLength = 0
+    def failedTests = false
+    def summaryLines = []
+    def totalcount = 0
+    def totalsuccess = 0
+    def totalfail = 0
+    def totalskip = 0
+    def totaltime = TimeCategory.getSeconds(0)
+    // sort on project name then task name
+    allResults.sort {a, b -> a[0] == b[0]? a[1]<=>b[1]:a[0] <=> b[0]}.each {
+      def projectName = it[0]
+      def taskName = it[1]
+      def result = it[2]
+      def time = it[3]
+      def report = it[4]
+      def summaryCol = getSummaryLine(styler, projectName, taskName, result.resultType, result.testCount, result.successfulTestCount, result.failedTestCount, result.skippedTestCount, time, true)
+      def summaryPlain = getSummaryLine(styler, projectName, taskName, result.resultType, result.testCount, result.successfulTestCount, result.failedTestCount, result.skippedTestCount, time, false)
+      def reportLine = "Report file: ${report}"
+      def ls = summaryPlain.length()
+      def lr = reportLine.length()
+      def m = [ls, lr].max()
+      if (m > maxLength)
+        maxLength = m
+      def info = [ls, summaryCol, reportLine]
+      summaryLines.add(info)
+      failedTests |= result.resultType == TestResult.ResultType.FAILURE
+      totalcount += result.testCount
+      totalsuccess += result.successfulTestCount
+      totalfail += result.failedTestCount
+      totalskip += result.skippedTestCount
+      totaltime += time
+    }
+    def totalSummaryCol = getSummaryLine(styler, "OVERALL", "", failedTests?TestResult.ResultType.FAILURE:TestResult.ResultType.SUCCESS, totalcount, totalsuccess, totalfail, totalskip, totaltime, true)
+    def totalSummaryPlain = getSummaryLine(styler, "OVERALL", "", failedTests?TestResult.ResultType.FAILURE:TestResult.ResultType.SUCCESS, totalcount, totalsuccess, totalfail, totalskip, totaltime, false)
+    def tls = totalSummaryPlain.length()
+    if (tls > maxLength)
+      maxLength = tls
+    def info = [tls, totalSummaryCol, null]
+    summaryLines.add(info)
+
+    def allSummaries = []
+    for(sInfo : summaryLines) {
+      def ls = sInfo[0]
+      def summary = sInfo[1]
+      def report = sInfo[2]
+
+      StringBuilder sb = new StringBuilder()
+      sb.append("│" + summary + " " * (maxLength - ls) + "│")
+      if (report != null) {
+        sb.append("\n│" + report + " " * (maxLength - report.length()) + "│")
+      }
+      allSummaries += sb.toString()
+    }
 
-  // not running tests in this task
-  exclude "**/*"
+    println "┌${"${"─" * maxLength}"}┐"
+    println allSummaries.join("\n├${"${"─" * maxLength}"}┤\n")
+    println "└${"${"─" * maxLength}"}┘"
 }
+/* END of test tasks results summary */
 
 
 task compileLinkCheck(type: JavaCompile) {
@@ -2138,8 +2237,8 @@ task getdownWebsite() {
       props.put("getdown_txt_ui.instant_background_image", "${getdownImagesBuildDir}/${getdown_instant_background_image}")
       props.put("getdown_txt_ui.error_background", "${getdownImagesBuildDir}/${getdown_error_background}")
       props.put("getdown_txt_ui.progress_image", "${getdownImagesBuildDir}/${getdown_progress_image}")
-      props.put("getdown_txt_ui.icon", "${getdownImagesBuildDir}/${getdown_icon}")
-      props.put("getdown_txt_ui.mac_dock_icon", "${getdownImagesBuildDir}/${getdown_mac_dock_icon}")
+      props.put("getdown_txt_ui.icon", "${getdownImagesDir}/${getdown_icon}")
+      props.put("getdown_txt_ui.mac_dock_icon", "${getdownImagesDir}/${getdown_mac_dock_icon}")
     }
 
     props.put("getdown_txt_title", jalview_name)