*/

package org.gradle.internal.cc.impl

class ConfigurationCacheSkipCacheIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "skip reading cached state on #commandLine"() {

        def configurationCache = newConfigurationCacheFixture()

        given:
        buildFile << """
            abstract class MyTask extends DefaultTask {

            import ${Project.name};
            import ${Plugin.name};
            import ${Task.name};
            ${read.requiredImports().collect { "import $it;" }.join("\n")}

            public class SneakyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Object value = ${read.javaExpression};
                    System.out.println("apply = " + value);

        this.useDefaultListeners = useDefaultListeners;
    }

    /**
     * Sets a custom threadPoolExecutorFactory class.
     * This should be a fully qualified class name and the class should implement org.testng.IExecutorFactory
     * More details in https://github.com/testng-team/testng/pull/2042
     * Requires TestNG 7.0 or higher
     * @since 8.7
     */

/**
 * Root element of the <code>lifecycle.xml</code> file.
 *
 * @version $Revision$ $Date$
 */
@SuppressWarnings("all")
public class LifecycleConfiguration implements java.io.Serializable {

    // --------------------------/
    // - Class/Member Variables -/
    // --------------------------/

    /**
     * Field lifecycles.
     */
    private java.util.List<Lifecycle> lifecycles;

import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import java.net.URI


@ServiceScope(Scope.BuildTree::class)
class RemoteScriptUpToDateChecker(
    private val lockingAccessCoordinator: ArtifactCacheLockingAccessCoordinator,
    private val startParameter: ConfigurationCacheStartParameter,

            when (clazz) {
                ConfigurationCacheEnvironmentChangeTracker.SystemPropertyMutate::class.java ->
                    ConfigurationCacheEnvironmentChangeTracker.SystemPropertyMutate(key, value, PropertyTrace.Unknown)
                ConfigurationCacheEnvironmentChangeTracker.SystemPropertyLoad::class.java ->
                    ConfigurationCacheEnvironmentChangeTracker.SystemPropertyLoad(key, value, null)

private
class NullableDynamicPropertyDelegate(
    private val dynamicLookupRoutine: DynamicLookupRoutine,
    private val owner: DynamicObject,
    private val name: String
) : PropertyDelegate {

    override fun <T> getValue(receiver: Any?, property: KProperty<*>): T =
        uncheckedCast(dynamicLookupRoutine.findProperty(owner, name))
}


private
class NonNullDynamicPropertyDelegate(

import org.gradle.internal.component.model.VariantGraphResolveState;
import org.gradle.internal.model.ModelContainer;

import javax.annotation.Nullable;
import javax.inject.Inject;
import java.lang.ref.SoftReference;

public class DefaultRootComponentMetadataBuilder implements RootComponentMetadataBuilder, HoldsProjectState {
    private final DependencyMetaDataProvider metadataProvider;
    private final ComponentIdentifierFactory componentIdentifierFactory;

import org.gradle.internal.service.scopes.ServiceScope
import org.gradle.util.internal.GFileUtils
import java.io.File
import java.util.EnumSet
import javax.inject.Inject


@ServiceScope(BuildTree::class)
class DefaultIgnoredConfigurationInputs(
    ignoredPathsString: String?,
    isCaseSensitive: Boolean,
    private val rootDirectory: File
) : IgnoredConfigurationInputs {

    @Inject

        sourceFile << """
            import ${Project.name}
            import ${Plugin.name}

            ${read.requiredImports().collect { "import $it" }.join("\n")}

            class SneakyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    def value = ${read.groovyExpression}
                    println("apply = " + value)