Remove deprecation warnings to prepare for Gradle 5

Gradle replaced `project.sourceSets.main.output.classesDir` of type
`File` with `project.sourceSets.main.output.classesDirs` of type
`FileCollection`
(see [SourceSetOutput](https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/java/org/gradle/api/tasks/SourceSetOutput.java))
Build output is now stored on a per language folder.

There are a few places where we use that, here's these and how it's
fixed:

- Randomized Test execution
    - look in all test folders ( pass the multi dir configuration to the
    ant runner )
    - DRY the task configuration by introducing `basedOn` for
      `RandomizedTestingTask` DSL
- Extend the naming convention test to support passing in multiple
  directories
- Fix the standalon test plugin, the dires were not passed trough,
  checked with a debuger and the statement had no affect due to a
  missing `=`.

Closes #30354

Author: alpar-t

buildSrc/src/main/groovy/com/carrotsearch/gradle/junit4/RandomizedTestingPlugin.groovy

@@ -13,7 +13,7 @@ class RandomizedTestingPlugin implements Plugin<Project> {
 
     void apply(Project project) {
         setupSeed(project)
-        replaceTestTask(project.tasks)
+        replaceTestTask(project)
         configureAnt(project.ant)
     }
 
@@ -44,24 +44,24 @@ class RandomizedTestingPlugin implements Plugin<Project> {
         }
     }
 
-    static void replaceTestTask(TaskContainer tasks) {
+    static void replaceTestTask(Project project) {
+        def tasks = project.tasks
         Test oldTestTask = tasks.findByPath('test')
         if (oldTestTask == null) {
             // no test task, ok, user will use testing task on their own
             return
         }
         tasks.remove(oldTestTask)
 
-        Map properties = [
+        RandomizedTestingTask newTestTask = tasks.create([
             name: 'test',
             type: RandomizedTestingTask,
             dependsOn: oldTestTask.dependsOn,
             group: JavaBasePlugin.VERIFICATION_GROUP,
             description: 'Runs unit tests with the randomized testing framework'
-        ]
-        RandomizedTestingTask newTestTask = tasks.create(properties)
+        ])
         newTestTask.classpath = oldTestTask.classpath
-        newTestTask.testClassesDir = oldTestTask.project.sourceSets.test.output.classesDir
+        newTestTask.testClassesDirs = oldTestTask.project.sourceSets.test.output.classesDirs
         // since gradle 4.5, tasks immutable dependencies are "hidden" (do not show up in dependsOn)
         // so we must explicitly add a dependency on generating the test classpath
         newTestTask.dependsOn('testClasses')

buildSrc/src/main/groovy/com/carrotsearch/gradle/junit4/RandomizedTestingTask.groovy

@@ -6,18 +6,20 @@ import groovy.xml.NamespaceBuilder
 import groovy.xml.NamespaceBuilderSupport
 import org.apache.tools.ant.BuildException
 import org.apache.tools.ant.DefaultLogger
+import org.apache.tools.ant.Project
 import org.apache.tools.ant.RuntimeConfigurable
 import org.apache.tools.ant.UnknownElement
+import org.elasticsearch.gradle.BuildPlugin
 import org.gradle.api.DefaultTask
 import org.gradle.api.InvalidUserDataException
 import org.gradle.api.file.FileCollection
 import org.gradle.api.file.FileTreeElement
-import org.gradle.api.internal.tasks.options.Option
 import org.gradle.api.specs.Spec
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.options.Option
 import org.gradle.api.tasks.util.PatternFilterable
 import org.gradle.api.tasks.util.PatternSet
 import org.gradle.internal.logging.progress.ProgressLoggerFactory
@@ -43,8 +45,8 @@ class RandomizedTestingTask extends DefaultTask {
     @Input
     String parallelism = '1'
 
-    @InputDirectory
-    File testClassesDir
+    @Input
+    FileCollection testClassesDirs
 
     @Optional
     @Input
@@ -95,6 +97,17 @@ class RandomizedTestingTask extends DefaultTask {
         listenersConfig.listeners.add(new TestReportLogger(logger: logger, config: testLoggingConfig))
     }
 
+    void basedOn(RandomizedTestingTask other) {
+        configure(BuildPlugin.commonTestConfig(project))
+        classpath = other.classpath;
+        testClassesDirs = other.testClassesDirs;
+        dependsOn = other.dependsOn
+        other.mustRunAfter this
+        if (project.tasks.findByPath("check") != null) {
+            project.tasks.check.dependsOn this
+        }
+    }
+
     @Inject
     ProgressLoggerFactory getProgressLoggerFactory() {
         throw new UnsupportedOperationException()
@@ -211,7 +224,7 @@ class RandomizedTestingTask extends DefaultTask {
 
         DefaultLogger listener = null
         ByteArrayOutputStream antLoggingBuffer = null
-        if (logger.isInfoEnabled() == false) {
+        if (!logger.isInfoEnabled()) {
             // in info logging, ant already outputs info level, so we see everything
             // but on errors or when debugging, we want to see info level messages
             // because junit4 emits jvm output with ant logging
@@ -220,15 +233,15 @@ class RandomizedTestingTask extends DefaultTask {
                 listener = new DefaultLogger(
                         errorPrintStream: System.err,
                         outputPrintStream: System.out,
-                        messageOutputLevel: org.apache.tools.ant.Project.MSG_INFO)
+                        messageOutputLevel: Project.MSG_INFO)
             } else {
                 // we want to buffer the info, and emit it if the test fails
                 antLoggingBuffer = new ByteArrayOutputStream()
                 PrintStream stream = new PrintStream(antLoggingBuffer, true, "UTF-8")
                 listener = new DefaultLogger(
                         errorPrintStream: stream,
                         outputPrintStream: stream,
-                        messageOutputLevel: org.apache.tools.ant.Project.MSG_INFO)
+                        messageOutputLevel: Project.MSG_INFO)
             }
             project.ant.project.addBuildListener(listener)
         }
@@ -251,12 +264,10 @@ class RandomizedTestingTask extends DefaultTask {
                 if (argLine != null) {
                     jvmarg(line: argLine)
                 }
-                fileset(dir: testClassesDir) {
-                    for (String includePattern : patternSet.getIncludes()) {
-                        include(name: includePattern)
-                    }
-                    for (String excludePattern : patternSet.getExcludes()) {
-                        exclude(name: excludePattern)
+                testClassesDirs.each { testClassDir ->
+                    fileset(dir: testClassDir) {
+                        patternSet.getIncludes().each { include(name: it) }
+                        patternSet.getExcludes().each { exclude(name: it) }
                     }
                 }
                 for (Map.Entry<String, Object> prop : systemProperties) {

buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy

@@ -726,7 +726,7 @@ class BuildPlugin implements Plugin<Project> {
         project.extensions.add('additionalTest', { String name, Closure config ->
             RandomizedTestingTask additionalTest = project.tasks.create(name, RandomizedTestingTask.class)
             additionalTest.classpath = test.classpath
-            additionalTest.testClassesDir = test.testClassesDir
+            additionalTest.testClassesDirs = test.testClassesDirs
             additionalTest.configure(commonTestConfig(project))
             additionalTest.configure(config)
             test.dependsOn(additionalTest)

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/LoggerUsageTask.groovy

@@ -50,11 +50,11 @@ public class LoggerUsageTask extends LoggedExec {
                 List files = []
                 // But only if the source sets that will make them exist
                 if (project.sourceSets.findByName("main")) {
-                    files.add(project.sourceSets.main.output.classesDir)
+                    files.add(project.sourceSets.main.output.classesDirs.getFiles())
                     dependsOn project.tasks.classes
                 }
                 if (project.sourceSets.findByName("test")) {
-                    files.add(project.sourceSets.test.output.classesDir)
+                    files.add(project.sourceSets.test.output.classesDirs.getFiles())
                     dependsOn project.tasks.testClasses
                 }
                 /* In an extra twist, it isn't good enough that the source set

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/NamingConventionsTask.groovy

@@ -24,7 +24,6 @@ import org.elasticsearch.gradle.VersionProperties
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.OutputFile
 /**
  * Runs NamingConventionsCheck on a classpath/directory combo to verify that
@@ -66,9 +65,9 @@ public class NamingConventionsTask extends LoggedExec {
     @Input
     boolean checkForTestsInMain = false;
 
-    public NamingConventionsTask() {
+    NamingConventionsTask() {
         // Extra classpath contains the actual test
-        if (false == project.configurations.names.contains('namingConventions')) {
+        if (!project.configurations.names.contains('namingConventions')) {
             project.configurations.create('namingConventions')
             Dependency buildToolsDep = project.dependencies.add('namingConventions',
                     "org.elasticsearch.gradle:build-tools:${VersionProperties.elasticsearch}")
@@ -81,11 +80,18 @@ public class NamingConventionsTask extends LoggedExec {
         inputs.files(classpath)
         description = "Tests that test classes aren't misnamed or misplaced"
         executable = new File(project.runtimeJavaHome, 'bin/java')
-        if (false == checkForTestsInMain) {
+
+        def dirsToUse = (checkForTestsInMain ?
+            project.sourceSets.main.output.classesDirs :
+            project.sourceSets.test.output.classesDirs)
+                .filter {it.exists()}
+                .collect {it.getAbsolutePath()}
+
+        if (!checkForTestsInMain) {
             /* This task is created by default for all subprojects with this
              * setting and there is no point in running it if the files don't
              * exist. */
-            onlyIf { project.sourceSets.test.output.classesDir.exists() }
+            onlyIf { dirsToUse.size() != 0 }
         }
 
         /*
@@ -111,16 +117,17 @@ public class NamingConventionsTask extends LoggedExec {
                 if (':build-tools'.equals(project.path)) {
                     args('--self-test')
                 }
+
                 if (checkForTestsInMain) {
                     args('--main')
                     args('--')
-                    args(project.sourceSets.main.output.classesDir.absolutePath)
                 } else {
                     args('--')
-                    args(project.sourceSets.test.output.classesDir.absolutePath)
                 }
+                args(dirsToUse.join(File.pathSeparator))
             }
         }
         doLast { successMarker.setText("", 'UTF-8') }
     }
+
 }

buildSrc/src/main/groovy/org/elasticsearch/gradle/test/RestIntegTestTask.groovy

@@ -61,7 +61,7 @@ public class RestIntegTestTask extends DefaultTask {
         clusterInit = project.tasks.create(name: "${name}Cluster#init", dependsOn: project.testClasses)
         runner.dependsOn(clusterInit)
         runner.classpath = project.sourceSets.test.runtimeClasspath
-        runner.testClassesDir = project.sourceSets.test.output.classesDir
+        runner.testClassesDirs = project.sourceSets.test.output.classesDirs
         clusterConfig = project.extensions.create("${name}Cluster", ClusterConfiguration.class, project)
 
         // start with the common test configuration

buildSrc/src/main/groovy/org/elasticsearch/gradle/test/StandaloneTestPlugin.groovy

@@ -46,7 +46,7 @@ public class StandaloneTestPlugin implements Plugin<Project> {
         test.configure(BuildPlugin.commonTestConfig(project))
         BuildPlugin.configureCompile(project)
         test.classpath = project.sourceSets.test.runtimeClasspath
-        test.testClassesDir project.sourceSets.test.output.classesDir
+        test.testClassesDirs = project.sourceSets.test.output.classesDirs
         test.mustRunAfter(project.precommit)
         project.check.dependsOn(test)
     }

buildSrc/src/main/java/org/elasticsearch/test/NamingConventionsCheck.java

@@ -19,6 +19,7 @@
 
 package org.elasticsearch.test;
 
+import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 import java.nio.file.FileVisitResult;
@@ -30,6 +31,7 @@
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
+import java.util.regex.Pattern;
 
 /**
  * Checks that all tests in a directory are named according to our naming conventions. This is important because tests that do not follow
@@ -47,7 +49,7 @@ public class NamingConventionsCheck {
     public static void main(String[] args) throws IOException {
         Class<?> testClass = null;
         Class<?> integTestClass = null;
-        Path rootPath = null;
+        String rootPathList = null;
         boolean skipIntegTestsInDisguise = false;
         boolean selfTest = false;
         boolean checkMainClasses = false;
@@ -70,18 +72,21 @@ public static void main(String[] args) throws IOException {
                     checkMainClasses = true;
                     break;
                 case "--":
-                    rootPath = Paths.get(args[++i]);
+                    rootPathList = args[++i];
                     break;
                 default:
                     fail("unsupported argument '" + arg + "'");
             }
         }
 
         NamingConventionsCheck check = new NamingConventionsCheck(testClass, integTestClass);
-        if (checkMainClasses) {
-            check.checkMain(rootPath);
-        } else {
-            check.checkTests(rootPath, skipIntegTestsInDisguise);
+        for (String rootDir : rootPathList.split(Pattern.quote(File.pathSeparator))) {
+            Path rootPath = Paths.get(rootDir);
+            if (checkMainClasses) {
+                check.checkMain(rootPath);
+            } else {
+                check.checkTests(rootPath, skipIntegTestsInDisguise);
+            }
         }
 
         if (selfTest) {

server/build.gradle

@@ -326,15 +326,9 @@ dependencyLicenses {
 }
 
 if (isEclipse == false || project.path == ":server-tests") {
-  task integTest(type: RandomizedTestingTask,
-                 group: JavaBasePlugin.VERIFICATION_GROUP,
-                 description: 'Multi-node tests',
-                 dependsOn: test.dependsOn) {
-    configure(BuildPlugin.commonTestConfig(project))
-    classpath = project.test.classpath
-    testClassesDir = project.test.testClassesDir
+  task integTest(type: RandomizedTestingTask,group: JavaBasePlugin.VERIFICATION_GROUP) {
+    description = 'Multi-node tests'
+    basedOn tasks.test
     include '**/*IT.class'
   }
-  check.dependsOn integTest
-  integTest.mustRunAfter test
 }

x-pack/plugin/ml/build.gradle

@@ -90,20 +90,13 @@ run {
 // so we disable integ tests
 integTest.enabled = false
 
-// Instead we create a separate task to run the
-// tests based on ESIntegTestCase
-task internalClusterTest(type: RandomizedTestingTask,
-                         group: JavaBasePlugin.VERIFICATION_GROUP,
-                         description: 'Multi-node tests',
-                         dependsOn: test.dependsOn) {
-  configure(BuildPlugin.commonTestConfig(project))
-  classpath = project.test.classpath
-  testClassesDir = project.test.testClassesDir
-  include '**/*IT.class'
-  systemProperty 'es.set.netty.runtime.available.processors', 'false'
+// Instead we create a separate task to run the tests based on ESIntegTestCase
+task internalClusterTest(type: RandomizedTestingTask, group: JavaBasePlugin.VERIFICATION_GROUP) {
+    description =  'Multi-node tests'
+    basedOn tasks.test
+    include '**/*IT.class'
+    systemProperty 'es.set.netty.runtime.available.processors', 'false'
 }
-check.dependsOn internalClusterTest
-internalClusterTest.mustRunAfter test
 
 // also add an "alias" task to make typing on the command line easier
 task icTest {