* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.smoketests

import org.gradle.testkit.runner.TaskOutcome

class GradleBuildSmokeTestConfigurationCacheSmokeTest extends AbstractGradleBuildConfigurationCacheSmokeTest {
    def "can run Gradle smoke tests with configuration cache enabled"() {

        given:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.smoketests

import org.gradle.testkit.runner.GradleRunner

class AnnotationProcessingSmokeTest extends AbstractSmokeTest {

    def 'project lombok works when options.fork=#fork'() {
        given:
        buildFile << """
            plugins {

        """
        def resolve = new ResolveTestFixture(new TestFile(buildFile), 'testCompileClasspath')
        resolve.prepare()

        when:
        def runner = runner('checkDep')
        if (bomSupportProvider == "spring dependency management plugin") {

        }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressedWithHighRelativeMedianDifference()
    }

    private setupRunner() {
        def iterations = determineIterations()
        runner.warmUpRuns = iterations
        runner.runs = iterations
    }

    private determineIterations() {

        given:
        runner.tasksToRun = ["assemble"]
        // use the deprecated property so it works with previous versions
        runner.args = ["-D${ConfigurationCacheOption.DEPRECATED_PROPERTY_NAME}=true"]

        and:
        runner.useDaemon = daemon == hot
        runner.addBuildMutator { configurationCacheInvocationListenerFor(it, action, stateDirectory) }
        runner.warmUpRuns = daemon == hot ? 20 : 1

import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Indicates that the test runner should only create execution if the feature is enabled, where enabled means
 * that the feature value is the one defined by {@link #value()}.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})

            package example;

            public class Application {
                public static void main(String[] args) {}
            }
        """.stripIndent()

        when:
        def result = runner('spotbugsMain').build()

        then:
        file('build/reports/spotbugs').isDirectory()
    }

    @Override
    Map<String, Versions> getPluginsToValidate() {
        [

        // The generated dependency graph is rather complex and deep, unrealistic?
        // 'nativeDependentsDeep' | 'libA0:buildDependentsLibA0'
        given:
        runner.tasksToRun = [task]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

        where:

import org.gradle.internal.declarativedsl.evaluator.DeclarativeDslNotEvaluatedException
import org.gradle.internal.declarativedsl.evaluator.DeclarativeKotlinScriptEvaluator
import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult
import javax.inject.Inject


@Suppress("unused") // The name of this class is hardcoded in Gradle
internal
class DeclarativeDslScriptPluginFactory @Inject constructor(

            import java.util.Set;

            public class Test {

                public static void main(String[] args) {
                }

            }
        """

        expect:
        runner('compileJava').forwardOutput().build()
    }

    @Override
    Map<String, Versions> getPluginsToValidate() {
        [
            'net.ltgt.errorprone': Versions.of(TestedVersions.errorProne)
        ]
    }