build.gradle

/*
 * build.gradle for Randoop
 *
 * Quick instructions: in project directory run with command
 *   ./gradlew build
 */

plugins {
  id 'com.github.johnrengelman.shadow' version '2.0.1'
  id 'java'
  id 'eclipse'
  id 'idea'
  id 'jacoco'

  // grgit has too many limitations; don't use it.
  // /* https://github.com/ajoberstar/gradle-git */
  // id 'org.ajoberstar.grgit' version '1.4.2'

  /*
   * Plugin that applies Google-Java-format to the Java files in the project.
   * https://github.com/sherter/google-java-format-gradle-plugin
   */
  id 'com.github.sherter.google-java-format' version '0.6'

  /*
   * Plugin that applies Google's Error Prone linter (http://errorprone.info/).
   * https://github.com/tbroyer/gradle-errorprone-plugin
   * Elsewhere this file excludes src/testinput from directories examined by Error Prone.
   * To run Error Prone, do:  ./gradlew compileJava
   * There is no separate target to just run Error Prone.
   */
  id "net.ltgt.errorprone-base" version "0.0.11" // 0.0.13 does not work with Java 7
}

/* Common build configuration for Randoop and agents */
allprojects {

  apply plugin: 'java'
  apply plugin: 'com.github.johnrengelman.shadow'

  sourceCompatibility = 1.7
  targetCompatibility = 1.7

  /* Use Maven Central when have external dependencies */
  repositories {
    mavenCentral()
    jcenter()
  }

  /* Randoop version number - added to generated jar files */
  version = '3.1.5'
}

/******
 * Configuration specific to Randoop and not agents
 * Configuration for agent FOO appears in agents/FOO/FOO.gradle .
 ******/

description = "Randoop automated test generation"

/* Root for working directories for system test generated files */
def workingDirectories = "$buildDir/working-directories"

sourceSets {
  /* JUnit tests that must be run with -javaagent */
  /* JUnit tests are run in nondeterministic order, but system tests are
     run in deterministic order. */
  coveredTest {
    java {
      srcDir 'src/coveredtest/java'
    }
    resources {
      srcDir 'src/coveredtest/resources'
    }
  }

  replacecallTest {
    java {
      srcDir 'src/replacecalltest/java'
    }
    resources {
      srcDir 'src/replacecalltest/resources'
    }
  }

  /* system tests */
  systemTest {
    java {
      srcDir 'src/systemtest/java'
    }
    resources {
      srcDir 'src/systemtest/resources'
      srcDir 'src/testinput/resources'
    }
    output.dir(workingDirectories, builtBy: 'generateWorkingDirs')
  }

  /* Code sets used by system tests. There are no actual tests here. */
  testInput {
    java {
      srcDir 'src/testinput/java'
    }
    resources {
      srcDir 'src/testinput/resources'
    }
  }

  test {
    resources {
      srcDir 'src/testinput/resources'
    }
  }
}

configurations {
  plume
  implementation.extendsFrom plume

  manual {
    description = "Generate user and developer documentation"
    extendsFrom plume
  }

  /*
   * Used to manage javaagent jar file
   */
  jacocoagent

  /*
   * The agent tests are JUnit tests run with the covered-class-agent, so
   * borrow from unit test configurations.
   */
  coveredTestImplementation.extendsFrom testImplementation
  coveredTestRuntimeOnly.extendsFrom testRuntimeOnly
  replacecallTestImplementation.extendsFrom testImplementation
  replacecallTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
  /* Randoop uses local copy of Plume */
  plume files('lib/plume.jar')
  implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.0'
  implementation group: 'junit', name: 'junit', version: '4.+'
  implementation files(project(':replacecall').sourceSets.main.output)

  /* JavaParser 2.4.0 is the most recent version available with JDK7 jar files. */
  implementation group: 'com.github.javaparser', name: 'javaparser-core', version: '2.4.0'

  /* sourceSet test uses JUnit and some use testInput source set */
  testImplementation group: 'junit', name: 'junit', version: '4.+'
  testImplementation group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
  testImplementation sourceSets.testInput.output

  /*
   * sourceSet coveredTest uses output from main sourceSet, and agent projects.
   * (Also, see configuration block.)
   */
  coveredTestImplementation sourceSets.main.output
  coveredTestImplementation sourceSets.test.output
  coveredTestRuntimeOnly project(':covered-class')

  replacecallTestImplementation files(project(':replacecall').sourceSets.main.output)

  jacocoagent group: 'org.jacoco', name: 'org.jacoco.agent', version: '0.7.7.201606060606'

  /*
   * source set systemTest
   */
   systemTestImplementation files('lib/plume.jar')
   systemTestImplementation group: 'junit', name: 'junit', version: '4.+'
   systemTestImplementation group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
   systemTestImplementation group: 'org.jacoco', name: 'org.jacoco.core', version: '0.7.7.201606060606'
   systemTestImplementation group: 'org.jacoco', name: 'org.jacoco.report', version: '0.7.7.201606060606'
   systemTestRuntimeOnly sourceSets.testInput.output

  /*
   * sourceSet testInput depends on output of main.
   * Also, src/testinput/java/ps1/RatPolyTest.java uses JUnit
   */
  testInputImplementation sourceSets.main.output
  testInputImplementation group: 'junit', name: 'junit', version: '4.+'

  /*
   * building documentation uses Options doclet that is part of plume, and
   * requires compiled source.
   */
  manual sourceSets.main.output

  /* JavaParser used by Minimize for the manual */
  manual group: 'com.github.javaparser', name: 'javaparser-core', version: '2.4.0'
}

/*
 * Configuration for formatting
 */
googleJavaFormat {
  // TODO:
  //   toolVersion '1.3'
  exclude '**/CloneVisitor.java'
}

tasks.googleJavaFormat {
  group 'Formatting'
  description = "Reformat Java source code with Google-Java-format"
  exclude 'src/testinput'
}

tasks.verifyGoogleJavaFormat {
  group 'Formatting'
  description = "Check Java source code formatting with Google-Java-format"
  exclude 'src/testinput'
}

// should verifyGoogleJavaFormat before compiling
tasks.withType(JavaCompile) {
  dependsOn 'googleJavaFormat' // task name conflicts with plugin name
}

/*
 * Configuration for compilation.
 */
compileJava.options.compilerArgs = ['-Xlint','-g','-Xlint:-classfile']
compileTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileCoveredTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileReplacecallTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileSystemTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileTestInputJava.options.compilerArgs = ['-nowarn','-g','-Xlint:-classfile']

task compileAll() {
  dependsOn compileJava
  dependsOn compileTestJava
  dependsOn ':covered-class:compileJava'
  dependsOn ':covered-class:compileTestJava'
  dependsOn ':replacecall:compileJava'
  dependsOn ':covered-class:compileTestJava'
  dependsOn compileCoveredTestJava
  dependsOn compileReplacecallTestJava
  dependsOn compileSystemTestJava
}

// This isn't working; maybe I need to make it run first.
// Get early notification of any compilation failures, before running any tests
build.dependsOn compileAll

/*
 * Configuration for using Error Prone linter.
 *
 * Only works in Java 8+.
 */
import net.ltgt.gradle.errorprone.ErrorProneToolChain

tasks.withType(JavaCompile).each { t ->
  if (JavaVersion.current().isJava8Compatible()) {
    if (!t.name.equals("compileTestInputJava")) {
      t.toolChain ErrorProneToolChain.create(project)
      t.options.compilerArgs += [
        // undocumented, and suggestion seems bad
        '-Xep:NamedParameters:OFF'
        // TODO: uncomment once we run the Interning Checker on Randoop
        // '-Xep:ReferenceEquality:OFF'
        ]
    }
  }
}


/*
 * Configuration for clean
 */
clean.dependsOn ':replacecall:clean'
clean.dependsOn ':covered-class:clean'

/*
 * Configuration for testing.
 * In terms of build, we have two kinds of tests, both using JUnit.
 *   * Those in src/coveredtest require the covered-class Java agent.
 *   * Those in src/test are run without the agent.
 *     This second group includes tests that run the full Randoop over
 *     classes that (mostly) are located in src/testinput.
 */

/*
 * Configuration of test task from Java plugin.
 * Runs all tests in test sourceSet except those excluded below.
 */
test {

  /*
   * Set the working directory for JUnit tests to the resources directory
   * instead of the project directory.
   */
  workingDir = file("$buildDir/resources")

  /*
   * Show as much as possible to console.
   */
  testLogging {
    events 'started', 'passed'
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false

  /*
   * Temporary exclusion b/c script file uses generics as raw types and conflicts with
   * other uses of parsing.
   */
  exclude '**/randoop/test/SequenceTests.*'

  /*
   * Temporary exclusion b/c incomplete.
   */
  exclude '**/randoop/output/JUnitCreatorTest.*'

  /*
   * Problematic tests excluded during Gradle setup that need to be evaluated.
   * Unless otherwise noted, these are tests that were not previously run by
   * Makefile. However, some included tests were also not run, but are not
   * failing.
   */
  exclude 'randoop/test/NonterminatingInputTest.*'
  exclude 'randoop/test/EmptyTest.*'
  exclude 'randoop/test/RandoopPerformanceTest.*' /* had target but not run */
  exclude 'randoop/test/ForwardExplorerPerformanceTest.*'
  exclude 'randoop/test/ForwardExplorerTests2.*' /* sporadic heap space issue */
  exclude 'randoop/test/Test_SomeDuplicates.*'
  exclude 'randoop/test/Test_SomePass.*'
  exclude 'randoop/operation/OperationParserTests.*'
}

task coveredTest(type: Test, dependsOn: ['copyJars', 'compileTestJava']) {
  /*
   * Set the working directory for JUnit tests to the resources directory
   * instead of the project directory.
   */
  workingDir = sourceSets.coveredTest.output.resourcesDir
  testClassesDirs = sourceSets.coveredTest.output.classesDirs
  classpath = sourceSets.coveredTest.runtimeClasspath
  jvmArgs "-javaagent:$buildDir/libs/covered-class-${version}.jar"

  /*
   * Show as much as possible to console.
   */
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}

/*
 * Link the coveredTest task into project check task. Includes agent tests into
 * the project build task.
 */
check.dependsOn coveredTest

task replacecallTest(type: Test, dependsOn: 'copyJars') {
  workingDir = sourceSets.replacecallTest.output.resourcesDir
  testClassesDirs = sourceSets.replacecallTest.output.classesDirs
  classpath = sourceSets.replacecallTest.runtimeClasspath + files("$buildDir/libs/replacecall-${version}.jar")
  // use the replacecall agent using the exclusions file from replacecalltest/resources
  jvmArgs "-javaagent:$buildDir/libs/replacecall-${version}.jar=--dont-transform=replacecall-exclusions.txt,--debug"
  jvmArgs "-Xbootclasspath/a:$buildDir/libs/replacecall-${version}.jar"
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}
check.dependsOn replacecallTest

jacocoTestReport {
  group 'Report'
  reports {
    xml.enabled = true
    html.enabled = true
  }
}
// Expects these files to exist in build/javcoco/:
//   agentTest.exec
//   coveredTest.exec
//   systemTest.exec
//   test.exec
// What is creating the agentTest.exec files, and how do I create it?
// test.exec is the default, though it it also greated by "gradle test".
// jacocoTestReport.dependsOn agentTest
jacocoTestReport.dependsOn coveredTest
jacocoTestReport.dependsOn test

check.dependsOn jacocoTestReport

/*
 * Task to build the root directory of working directories used by the
 * JUnit tests in the systemTest task.
 * If the directory exists then cleans out the contents.
 */
task generateWorkingDirs {
  doLast {
    def generated = file(workingDirectories)
    if (! generated.exists()) {
      generated.mkdir()
    } else {
      def workingFiles = fileTree(workingDirectories) {
        include '**/*.java'
        include '**/*.class'
        include '**/*.exec'
        include '**/*.txt'
      }
      delete workingFiles
    }
  }
}

/*
 * Extracts JaCoCo javaagent into build/jacocoagent
 */
task extractJacocoAgent(type: Copy) {
  from {
    configurations.jacocoagent.collect { zipTree(it) }
  }
  into "$buildDir/jacocoagent/"
}

/*
 * Configuration of the systemTest task.
 * Runs JUnit over all classes in systemTest sourceSet.
 * JUnit tests assume that working directories can be found in the build directory.
 */
task systemTest(type: Test, dependsOn: [ 'extractJacocoAgent', 'generateWorkingDirs', 'assemble' ]) {

  /*
   * Set system properties for jar paths, used by randoop.main.SystemTestEnvironment
   */
  doFirst {
    systemProperty 'jar.randoop', shadowJar.archivePath
    systemProperty 'jar.replacecall.agent', project(':replacecall').shadowJar.archivePath
    systemProperty 'jar.covered.class.agent', project(':covered-class').shadowJar.archivePath
  }

  workingDir = file("$buildDir")
  testClassesDirs = sourceSets.systemTest.output.classesDirs
  classpath = sourceSets.systemTest.runtimeClasspath

  /*
   * Show as much as possible to console.
   */
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}

systemTest.dependsOn shadowJar

/*
 * Link the systemTest task into the project check task.
 * Includes system tests into the project build task.
 */
check.dependsOn systemTest
jacocoTestReport.dependsOn systemTest

tasks.withType(Test) {
 /*
  * Set the destination directory for JUnit XML output files
  */
  reports.junitXml.destination = file("$buildDir/test-results/${name}")
 /*
  * Set the heap size and GC for running tests.
  */
  jvmArgs '-Xmx384m', '-XX:+UseG1GC', '-XX:SoftRefLRUPolicyMSPerMB=250'

  /*
   * Pass along any system properties that begin with "randoop."
   * Used by randoop.main.RandoopOptions in systemtest.
   */
  System.properties.each { k,v->
        if (k.startsWith("randoop.")) {
            systemProperty k, v
        }
  }
}

/*
 * Configuration of task to write HTML reports into build/reports/allTests for
 * all tests.
 * [
 *   Note that this may not work correctly if different Test tasks use the same
 *   test classes. Fine here because sourceSets use different packages for test
 *   classes.
 * ]
 */
task testReport(type: TestReport) {
  group 'Report'
  description "Creates HTML reports for tests results"
  destinationDir = file("$buildDir/reports/allTests")
  reportOn tasks.withType(Test)
}

//****************** Building distribution *****************

/*
 * Only want the jar file to include class files from main source set.
 * (Task part of build by default.)
 */
jar {
  from sourceSets.main.output
}

// want to archive locally
uploadArchives {
  repositories {
    flatDir {
      dirs 'dist'
    }
  }
}

task copyJars(type: Copy, dependsOn: [':covered-class:jar', ':replacecall:jar']) {
  from subprojects.collect { it.tasks.withType(Jar) }
  into "$buildDir/libs"
}

assemble.dependsOn copyJars

shadowJar {
  // The jar file name is randoop-all-$version.jar
  baseName = 'randoop-all'
  classifier = null

  exclude '**/pom.*'
  exclude '**/default-*.txt'

  // don't include either mocks or agent classes
  // otherwise creates problems for replacement creation of replacecall agent
  exclude '**/randoop/mock/*'
  exclude '**/randoop/instrument/*'

  relocate 'com.github.javaparser', 'randoop.com.github.javaparser'
  relocate 'com.google', 'randoop.com.google'
  relocate 'com.jcraft.jsch', 'randoop.com.jcraft.jsch'
  relocate 'com.sun.javadoc', 'randoop.com.sun.javadoc'
  relocate 'com.sun.jna', 'randoop.com.sun.jna'
  relocate 'com.trilead.ssh2', 'randoop.com.trilead.ssh2'
  relocate 'de.regnis.q.sequence', 'randoop.de.regnis.q.sequence'
  relocate 'edu.emory.mathcs.backport.java.util', 'randoop.edu.emory.mathcs.backport.java.util'
  relocate 'net.fortuna.ical4j', 'randoop.net.fortuna.ical4j'
  relocate 'nu.xom', 'randoop.nu.xom'
  relocate 'org.antlr', 'randoop.org.antlr'
  relocate 'org.apache', 'randoop.org.apache'
  relocate 'org.ccil.cowan.tagsoup', 'randoop.org.ccil.cowan.tagsoup'
  relocate 'org.checkerframework', 'randoop.org.checkerframework'
  relocate 'org.ini4j', 'randoop.org.ini4j'
  relocate 'org.slf4j', 'randoop.org.slf4j'
  relocate 'org.tigris.subversion', 'randoop.org.tigris.subversion'
  relocate 'org.tmatesoft', 'randoop.org.tmatesoft'
  relocate 'plume', 'randoop.plume'
}

assemble.dependsOn shadowJar

task distributionZip (type: Zip , dependsOn: ['shadowJar', 'copyJars', 'manual']) {
  group 'Publishing'
  description "Assemble a zip file with jar files and user documentation"
  def dirName = "$baseName-$version"
  from 'build/libs/'
  from ('build/docs/manual/index.html') {
    into 'doc'
  }
  from ('build/docs/manual/stylesheets') {
    into 'doc/manual/stylesheets'
  }
  from 'src/distribution/resources/README.txt'
  into (dirName)
  exclude { details -> details.file.name.contains('randoop') && ! details.file.name.contains('-all-') }
}

/********************* Building manual *******************/
/*
 * The "manual" gradle target create the contents of the manual directory
 * within src/, which will eventually be moved to project docs directory.
 *
 * Has structure:
 *   docs/
 *     api/ - contains javadoc for main source set
 *     manual/
 *       dev.html - developer documentation
 *       index.html - user documentation
 *       *example.txt - example configuration files for user manual
 *       stylesheets/ - contains css file for web pages
 */

 /*
  * Get the plume-lib repo using gradle-git, and save into utils/plume-lib
  */
task clonePlumeLib {
  doLast {
    def plumeFolder = file("$buildDir/utils/plume-lib")
    if ( ! plumeFolder.exists() ) {
      // Grgit has too many limitations.  Use the command line instead.
      // // TODO: This should be a shallow clone, to make it complete faster.
      // // That's not yet supported: https://github.com/ajoberstar/grgit/issues/155 .
      // org.ajoberstar.grgit.Grgit.clone(dir: plumeFolder, uri: 'https://github.com/mernst/plume-lib.git')
      // // Unfortunately, grgit's clone of plume-lib has uncommitted changes
      // // (changes to execute bits).  Fix the two that matter.  (Don't set
      // // every file in plume-lib bin to executable, because that would also
      // // make changes, which would cause errors when pulling.)
      // exec {
      //   commandLine 'chmod', '+x', "$buildDir/utils/plume-lib/bin/preplace", "$buildDir/utils/plume-lib/bin/html-update-toc"
      // }

      exec {
        commandLine 'git', 'clone', '--depth', '1', "https://github.com/mernst/plume-lib.git", "$buildDir/utils/plume-lib"
      }
    } else {
      // Given that grgit is not used above, there's no point using it here.
      // def grgit = org.ajoberstar.grgit.Grgit.open(dir: plumeFolder)
      // grgit.pull()

      exec {
        workingDir "$buildDir/utils/plume-lib"
        // Ignore exit value so this works when not connected to the Internet.
        ignoreExitValue true
        commandLine 'git', 'pull', '-q'
      }
    }
  }
}

/*
 * Set destination directory to build/docs/api, and restrict to classes in
 * main sourceSet.
 */
javadoc {
  destinationDir = file("${buildDir}/docs/api")
  source sourceSets.main.allJava
  options.memberLevel = JavadocMemberLevel.PRIVATE
  options.addStringOption("stylesheetfile", "${projectDir}/src/javadoc/resources/stylesheets/javadocstyle.css")
  // Use of Javadoc's -linkoffline command-line option makes Javadoc generation
  // much faster, especially on Travis.
  options.with {
    linksOffline 'https://docs.oracle.com/javase/8/docs/api/', 'https://docs.oracle.com/javase/8/docs/api/'
  }
  failOnError = true
}

// needed for javadoc.doLast
javadoc.dependsOn clonePlumeLib

javadoc.doLast {
  def preplace = file("$buildDir/utils/plume-lib/bin/preplace")
  // Work around Javadoc bug
  exec {
    commandLine preplace, "<dt><span class=\"memberNameLink\"><a href=\".*\\(\\)</a></span> - Constructor for enum [a-zA-Z0-9_.]*<a href=\".*</a></dt>", "", "build/docs/api/index-all.html"
  }
  // Reduce size of diffs (when it's copied over to docs/api whech is under
  // version control).  Note that build/docs/api/ is the same as src/docs/api/.
  exec {
    commandLine preplace, "^<!-- Generated by javadoc \\(.* -->\$", "", "build/docs/api/"
  }
  exec {
    commandLine preplace, "^<meta name=\"date\" content=\"[-0-9]+\">\$", "", "build/docs/api/"
  }
}

/*
 * Make sure that build runs the same tasks as the script in .travis.yml
 */
build.dependsOn javadoc

/*
 * Configuration of updateUserTOC task to update the table-of-contents for the
 * user documentation.
 */
task updateUserTOC( type:Exec, dependsOn: [ 'clonePlumeLib' ]) {
  executable file("$buildDir/utils/plume-lib/bin/html-update-toc")
  args  file("${projectDir}/src/docs/manual/index.html")
  environment PATH: "$System.env.PATH:$buildDir/utils/plume-lib/bin"
}

/* Configuration of task updateDevTOC to update table of contents in developer
 * documentation.
 */
task updateDevTOC( type:Exec, dependsOn: ['clonePlumeLib' ]) {
  executable file("$buildDir/utils/plume-lib/bin/html-update-toc")
  args file("${projectDir}/src/docs/manual/dev.html")
  environment PATH: "$System.env.PATH:$buildDir/utils/plume-lib/bin"
}

/*
 * Applies plume.OptionsDoclet to src/docs/manual/index.html to add
 * command-line arguments extracted from the given @Option annotated classes.
 * Applied in-place.
 */
task updateUserOptions(dependsOn: 'assemble') {
  description "Runs plume.OptionsDoclet on src/docs/manual/index.html"
  def classpath = files(configurations.manual.files).asPath
  def docFile = file("${projectDir}/src/docs/manual/index.html")
  def options = [
    "-classpath", classpath,
    "-docletpath", classpath,
    "-doclet", "plume.OptionsDoclet",
    "-docfile", docFile,
    "-i",
  ]
  def fileList = [
    file("${projectDir}/src/main/java/randoop/main/GenInputsAbstract.java"),
    file("${projectDir}/src/main/java/randoop/generation/AbstractGenerator.java"),
    file("${projectDir}/src/main/java/randoop/util/ReflectionExecutor.java"),
    file("${projectDir}/src/main/java/randoop/main/Minimize.java")
  ]
  doLast {
    project.exec {
      commandLine = [ "javadoc" ] + options + fileList
    }
  }
}

/*
 * Configuration of manual task to generate/update and move documentation into
 * build/docs directory.
 */
task manual(type: DefaultTask, dependsOn: [ 'updateUserOptions', 'updateUserTOC', 'updateDevTOC']) {
  group 'Documentation'
  description "Adds options and TOC to documentation in src/docs"
  doLast {
    exec {
      if (JavaVersion.current().isJava8Compatible()) {
        environment PATH: "$System.env.PATH"
        commandLine "html5validator", "--root", file("${projectDir}/src/docs/manual")
      } else {
        commandLine "echo","WARNING: HTML validation of manuals is only run in Java 8+"
      }
    }
  }
}

build.dependsOn manual

/*
 * Applies HTML5 validator to API javadoc.
 * Note: prior to Java 9, javadoc does not comply with HTML5.
 */
task validateAPI(type: Exec, dependsOn: 'javadoc') {
  group 'Documentation'
  description "Run html5validator to find HTML errors in API documentation"
  if (JavaVersion.current().isJava9Compatible()) {
    environment PATH: "$System.env.PATH"
    commandLine "html5validator", "--root", file("${buildDir}/docs/api")
  } else {
    commandLine "echo", "WARNING: HTML validation of API is only run in Java 9+"
  }
}


/*
 * WARNING: do not run this task unless you mean to wipe out the project pages
 * directory. It can be repopulated by publishSite, but the contents will be
 * based on changes to the files in src/docs and the javadoc in the source.
 */
task cleanSite {
  group=null
  description 'Removes all files from the project pages directory (CAUTION!)'
  def siteDir = file("${projectDir}/docs")
  def oldSiteFiles = fileTree(siteDir) {
    exclude 'README.md'
  }
  doLast {
    delete oldSiteFiles
  }
}

/*
 * Publishes changes to the project documentation to the project pages directory
 * (docs). This task ensures that all old site files are removed, new javadoc is
 * generated, the manual is updated, and the HTML has been validated.
 *
 * Note that the contents of any subdirectory of build/docs will be included in
 * the site. Currently, this is only the api directory generated by the javadoc
 * task.
 *
 * All site files will be read-only.
 */
task publishSite (dependsOn: ['cleanSite', 'javadoc', 'validateAPI', 'manual']) {
  group 'Publishing'
  description 'Publish changes to site files and javadoc to the project pages directory'
  def siteDir = file("${projectDir}/docs")
  def buildDocsDir = file("${buildDir}/docs") // include any built docs (e.g., api)
  def newSiteFiles = fileTree("${projectDir}/src/docs") {
    exclude 'README.md'
    exclude 'api'
  }
  doLast {
      copy {
        from (buildDocsDir)  //copy api
        from (newSiteFiles)
        into siteDir
        fileMode = Integer.parseInt("444", 8)
      }
  }
}

/*
 * Applies HTML5 validator to project site HTML
 */
task validateSite(type: Exec) {
  description "Run html5validator to find HTML errors in site files (excludes manual and api)"
  if (JavaVersion.current().isJava8Compatible()) {
    environment PATH: "$System.env.PATH"
    commandLine "html5validator", "--root", "src/docs/", "--ignore", "src/docs/api"
    commandLine "html5validator", "--root", "docs/", "--ignore", "docs/api"
  } else {
    commandLine "echo", "WARNING: HTML validation of site is only run in Java 9+"
  }
}

task buildRelease(type: DefaultTask, dependsOn: [ 'assemble', 'check', 'publishSite', 'validateSite', 'distributionZip' ]) {
  group 'Publishing'
  description "Builds system and documentation, validates HTML, and publishes site"
}

/*************** Gradle Wrapper ******************/
/* Declares the Gradle version to be used when the wrapper is built */
task wrapper(type: Wrapper) {
  description "Configure Gradle Wrapper for this project"
  gradleVersion = '4.1'
}

/*************** Other tool configs *************/
/* Make Emacs TAGS table */
task tags(type: Exec, dependsOn: 'clonePlumeLib') {
  group 'Emacs'
  description "Run etags to create an Emacs TAGS table"
  environment PATH: "$System.env.PATH:$buildDir/utils/plume-lib/bin"
  commandLine "bash", "-c", "find src/ agent/covered-class/src/ agent/replacecall/src/ -name '*.java' | grep -v src/testinput | sort-directory-order | xargs etags"
}

/* Make Emacs TAGS table, with only Randoop code (not test code) */
task tagsNoTests(type: Exec, dependsOn: 'clonePlumeLib') {
  group 'Emacs'
  description "Run etags to create an Emacs TAGS table"
  environment PATH: "$System.env.PATH:$buildDir/utils/plume-lib/bin"
  commandLine "bash", "-c", "find src/ -name *.java | sort-directory-order | grep -v /testinput/ | xargs etags"
}

/* Run checklink */
task checklink(type: Exec, dependsOn: 'clonePlumeLib') {
  group 'Validation'
  description "Run checklink on randoop.github.io/randoop/ and write output to checklink-log.txt"
  environment PATH: "$System.env.PATH:$buildDir/utils/plume-lib/bin"
  commandLine 'bash', '-c', """
     checklink -q -r `grep -v '^#' build/utils/plume-lib/bin/checklink-args.txt` https://randoop.github.io/randoop/ &> checklink-log.txt
  """
}

task installGitHooks(type: Copy) {
  group=null
  description "Installs git hooks for pre-commit and managing docs permissions"
  from 'scripts/'
  into '.git/hooks'
}
/* Always run this task. */
tasks.installGitHooks.execute()