import org.gradle.api.plugins.quality.TargetJdk;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.provider.Property;

/**
 * Parameters used to configure a {@link PmdAction}.
 */
public interface PmdActionParameters extends AntWorkParameters {

    ConfigurableFileCollection getPmdClasspath();

    Property<TargetJdk> getTargetJdk();

    ListProperty<String> getRuleSets();

                pmdClasspath = pmdFileCollection
                ruleSetFiles = files()
                ruleSets = ["category/java/errorprone.xml"]
                rulesMinimumPriority = 5
                targetJdk = TargetJdk.VERSION_1_4
                threads = 1
                incrementalAnalysis = false
            }
        """

        when:
        succeeds("myPmd")

        then:

            </tr>
            <tr>
                <td>ruleSetFiles</td>
                <td><literal>[]</literal></td>
            </tr>
            <tr>
                <td>targetJdk</td>
                <td><literal>project.sourceCompatibility</literal></td>
            </tr>
            <tr>
                <td>ignoreFailures</td>
                <td><literal>false</literal></td>
            </tr>

        }
        if (withJavaExtension != null) {
            configureJavaPluginToolchainVersion(selectJdk(withJavaExtension))
        }

        def targetJdk = selectJdk(target)
        def groovyTarget = GroovyCoverage.getEffectiveTarget(versionNumber, targetJdk.javaVersion)

        when:
        withInstallations(currentJdk, otherJdk).run(":compileGroovy", "--info")

        then:

        }

        def targetJdk = selectJdk(target)

        when:
        withInstallations(currentJdk, otherJdk).run(":compileJava", "--info")

        then:
        executedAndNotSkipped(":compileJava")
        outputContains("Compiling with toolchain '${targetJdk.javaHome.absolutePath}'")
        classJavaVersion(javaClassFile("Foo.class")) == targetJdk.javaVersion

        where:

        }

        def targetJdk = selectJdk(target)

        when:
        withInstallations(currentJdk, otherJdk).run(":compileScala", "--info")

        then:
        executedAndNotSkipped(":compileScala")
        outputContains("Compiling with Zinc Scala compiler")

        JavaVersion.forClass(scalaClassFile("JavaThing.class").bytes) == targetJdk.javaVersion

            // http://sourceforge.net/p/pmd/bugs/1004/
            // http://java-pmd.30631.n5.nabble.com/pmd-pmd-db05bc-pmd-AntTask-support-for-language-td5710041.html
            antPmdArgs["targetjdk"] = parameters.targetJdk.get().name

            htmlFormat = "betterhtml"

            // fallback to basic on pre 5.0 for backwards compatible

            testing.suites.test.useJUnit()

            pmd {
                toolVersion = '$version'
                // Set target JDK for PMD <5.x tests, so the test code is accepted
                targetJdk = TargetJdk.VERSION_1_7
                ${supportIncrementalAnalysis() ? "" : "incrementalAnalysis = false"}
            }

            ${fileLockingIssuesSolved() ? "" : """
            tasks.withType(Pmd) {

            }

            def requestedGradleVersion = project.findProperty("gradleVersion")
            def requestedTargetJdk = project.findProperty("targetJdk")

            // Earlier versions of Gradle can sometimes fail to connect to the just started Gradle daemon.
            // The failure will be the "tried to connect to 100 daemons" error

    buildFeatures {
      buildConfig = false
    }

    testOptions {
      unitTests {
        isIncludeAndroidResources = true
      }

      targetSdk = 34
    }
  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)
  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()