build.gradle

import groovy.time.TimeDuration
import groovy.time.TimeCategory

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'biz.aQute.bnd:biz.aQute.bnd.gradle:4.1.0'
  }
}

plugins {
  id "biz.aQute.bnd.builder" version "6.3.1" apply false
}

ext {
  testCount = 0
  successfulTestCount = 0
  failedTestCount = 0
  skippedTestCount = 0
  time = new TimeDuration(0,0,0,0)
  testsResults = []
}

wrapper {
    distributionType = Wrapper.DistributionType.ALL
}

/**
 * Compute a hash no longer than <code>length</code> for the git repository.
 * @param length
 * @return the hash as a string
 */
def getGitHash(length) {
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'rev-parse', "--short=$length", 'HEAD'
        standardOutput = stdout
    }
    return stdout.toString().trim()
}

def testProjects = "osgi util rmi-impl core test".split(" ").collect{s->project(":yoko-" + s)}
def shipProjects = "osgi util spec-corba rmi-spec rmi-impl core".split(" ").collect{s->project(":yoko-" + s)}



/* Standard configuration for each subproject */
subprojects { sp ->
  apply plugin: 'java-library'
  sourceCompatibility = 1.8
  targetCompatibility = 1.8

  repositories {
    mavenLocal()
    maven { url "https://repository.apache.org/snapshots" }
    maven { url "https://repo.maven.apache.org/maven2" }
  }

  configurations {
    // declare a test library configuration
    testLib
    testImplementation.extendsFrom testLib
  }

  // additional configuration for projects that have bnd.bnd files
  if (sp.file("bnd.bnd").exists()) {
    apply plugin: 'biz.aQute.bnd.builder'
    group = 'org.apache.yoko'
    // to extend the project with a new property, use project.ext.<new property name>
    project.ext.symbolicName = project.name.replaceFirst("^yoko-", project.group.toString() + ".")
    version = '1.5.0.' + getGitHash(10)
  }
}

/* Standard configuration for subprojects with tests */
configure(testProjects) {
  // standardise the test deps here
  dependencies {
    testLib 'junit:junit:4.12'
    testLib 'org.mockito:mockito-core:2.22.0'
    testLib 'org.mockito:mockito-junit-jupiter:2.22.0'
    testLib "org.hamcrest:hamcrest:2.1"
    testLib "org.junit.jupiter:junit-jupiter:5.8.2"
    testLib "org.junit.platform:junit-platform-runner:1.8.2"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.8.2"
    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:5.8.2"
  }

  if (JavaVersion.current() < JavaVersion.VERSION_11) {
    throw new GradleException("This build must be run with java 11 or higher")
  }

  // ensure tests run under $buildDir somewhere
  test {
    useJUnitPlatform()
    workingDir = "$buildDir/testWorkingDir"
    doFirst {workingDir.mkdirs()}

    testLogging {
      // set options for log level LIFECYCLE
      events "skipped", "failed", "passed", "standardOut"
      showExceptions true
      exceptionFormat "full"
      showCauses true
      showStackTraces true

      // set options for log level DEBUG and INFO
      debug {
        events "skipped", "failed", "started", "passed", "standardOut", "standardError"
        exceptionFormat "full"
      }
      info.events = debug.events
      info.exceptionFormat = debug.exceptionFormat
      ignoreFailures = true // Always try to run all tests for all modules

      afterTest { desc, result ->
        def totalTime = result.endTime - result.startTime
        println """"Test elapsed time","$desc.name",$totalTime"""
      }

      afterSuite { desc, result ->
        if (!desc.parent) { // will match the outermost suite
          def timeTaken = TimeCategory.minus(new Date(result.endTime), new Date(result.startTime))
          String summary = "${desc.name}" +
                  "\n" +
                  "Results: ${result.resultType} " +
                  "(" +
                  "${result.testCount} tests, " +
                  "${result.successfulTestCount} successes, " +
                  "${result.failedTestCount} failures, " +
                  "${result.skippedTestCount} skipped" +
                  ") " +
                  "in ${timeTaken}" +
                  "\n"
          rootProject.testCount += result.testCount
          rootProject.successfulTestCount += result.successfulTestCount
          rootProject.failedTestCount += result.failedTestCount
          rootProject.skippedTestCount += result.skippedTestCount
          rootProject.time += timeTaken

          // Add reports in `testsResults`, keep failed suites at the end
          if (result.resultType == TestResult.ResultType.SUCCESS) {
            rootProject.testsResults.add(0, summary)
          } else {
            rootProject.testsResults += summary
          }

          def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
          def startItem = '|  ', endItem = '  |'
          def repeatLength = startItem.length() + output.length() + endItem.length()
          println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
        }
        def totalTime = result.endTime - result.startTime
        println """"Suite elapsed time","$desc.name",$totalTime"""
      }
    }
  }
}

gradle.buildFinished {
  String overallSummary = "Total Summary" +
          "\n" +
          "Results: ${(failedTestCount == 0) ? "SUCCESS": "FAILURE"} " +
          "(" +
          "${rootProject.testCount} tests, " +
          "${rootProject.successfulTestCount} successes, " +
          "${rootProject.failedTestCount} failures, " +
          "${rootProject.skippedTestCount} skipped" +
          ") " +
          "in ${rootProject.time}" +
          "\n"
  rootProject.testsResults.add(overallSummary)

  def allResults = rootProject.testsResults
  if (!allResults.isEmpty()) {
    printResults rootProject.testsResults
  }
}

private static void printResults(allResults) {
  println "\n  \n Build Summary:"
  // Max line length has to take lines from all items into account
  def maxLength = allResults*.readLines().flatten().collect { it.length() }.max()

  println ",${"${"-" * maxLength}"}." // Top border

  println allResults.collect {
    it.readLines().collect { // Add left and right border to each _line_
      "|" + it + " " * (maxLength - it.length()) + "|"
    }.join("\n")
  }.join("\n+${"${"-" * maxLength}"}+\n") // Add separator between entries

  println "`${"${"-" * maxLength}"}'" // Print bottom border
}

/* Standard configuration for subprojects with shippable outputs */
configure(shipProjects) {
  apply plugin: 'maven-publish'
  publishing {
    publications {
      maven(MavenPublication) {
        artifact jar

        pom.withXml {
          def rootNode = asNode()

          // // specify packaging type as bundle (default is pom)
          // def packaging = root.packaging[0] ?:
          //                 root.appendNode('packaging')
          // packaging.setValue('bundle')

          def depsNode = rootNode.dependencies[0] ?:
                  rootNode.appendNode('dependencies')


          // declare compile scope dependencies in the pom.xml
          // as compile dependencies
          configurations.implementation.allDependencies.each {
            def depNode = depsNode.appendNode('dependency')
            depNode.appendNode('groupId', it.group)
            depNode.appendNode('artifactId', it.name)
            depNode.appendNode('version', it.version)
            depNode.appendNode('scope', 'compile')
          }
        }
      }
    }
  }

  jar {
    dependsOn "generatePomFileForMavenPublication"
    // generate the maven dependency metadata
    into("/META-INF/maven/$project.group/$project.name") {
      from 'build/publications/maven'
      rename "pom-default.xml", "pom.xml"
    }
  }

  publish.dependsOn build
  // generated tasks need to be expressed as strings
  // because they don't exist yet when these lines are executed
  publish.dependsOn "publishMavenPublicationToMavenLocal"
  publish.dependsOn "publishToMavenLocal"
}

// Summarise the number of tests
//gradle.buildFinished {
//  if (testCount == 0) return
//  def output = "FINAL RESULT: ${failedTestCount ? "FAILURE" : "SUCCESS"} (${testCount} tests, ${successfulTestCount} successes, ${failedTestCount} failures, ${skippedTestCount} skipped)"
//  def startItem = '|  ', endItem = '  |'
//  def repeatLength = startItem.length() + output.length() + endItem.length()
//  println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
//}