import spock.lang.Issue

class ConfigurationCacheFileCollectionIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "directory tree is treated as build input when its contents are queried during configuration"() {
        buildFile << """
            task report {
                def tree = fileTree("src")
                def file1 = file("src/file1")
                def result = $expression

	if gcphase != _GCoff {
		// Currently we assume that the finalizer queue won't
		// grow during marking so we don't have to rescan it
		// during mark termination. If we ever need to lift
		// this assumption, we can do it by adding the
		// necessary barriers to queuefinalizer (which it may
		// have automatically).
		throw("queuefinalizer during GC")
	}

	lock(&finlock)
	if finq == nil || finq.cnt == uint32(len(finq.fin)) {

		if len(f) < 3 {
			continue
		}
		name = append(name, absDomainName(f[2]))
	}
	return
}

// concurrentThreadsLimit returns the number of threads we permit to
// run concurrently doing DNS lookups.
func concurrentThreadsLimit() int {
	return 500

                // use a soft reference to allow the state to be GCed
                //
                // Also keep a soft reference to try to avoid recreating the state when it is queried during
                // work graph calculation and then later during resolution. It would be better if the configuration
                // implementation took care of this instead
                reference = new SoftReference<>(state);

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private Loader getLoader(ProtectionDomain domain) {
        // This is a very verbose Java 6-compatible way of doing
        // return loaders.computeIfAbsent(domain, this::createLoaderForDomain).
        Loader transformLoader = loaders.get(domain);
        if (transformLoader == null) {

import org.gradle.initialization.StartParameterBuildOptions

class ConfigurationCacheInputListenerLifecycleIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "configuration inputs are tracked during task graph serialization"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        and: "a project that has a provider having undeclared configuration inputs, which is linked to a task"

     *
     * @since 4.8
     */
    @Override
    AttributeContainer getAttributes();

    /**
     * Mutates the attributes of this dependency. Attributes are used during dependency resolution to select the appropriate
     * target variant, in particular when a single component provides different variants.
     *
     * @param configureAction the attributes mutation action
     * @return this

import org.gradle.internal.serialize.graph.runWriteOperation
import java.io.Closeable
import java.util.concurrent.CopyOnWriteArrayList


/**
 * Persists side effects observed during build action execution
 * and restores them on a subsequent load from the cache.
 *
 * @see BuildTreeModelSideEffect
 */
internal
class BuildTreeModelSideEffectStore(

	i istio.Instance

	// Below are various preconfigured echo deployments. Whenever possible, tests should utilize these
	// to avoid excessive creation/tear down of deployments. In general, a test should only deploy echo if
	// its doing something unique to that specific test.
	apps = &EchoDeployments{}
)

type EchoDeployments struct {
	// Namespace echo apps will be deployed
	Namespace namespace.Instance
	// Captured echo service

config.test_exec_root = os.environ['RUNFILES_DIR']

if platform.system() == 'Windows':
  tool_patterns = [
      ToolSubst('FileCheck.exe', unresolved='fatal'),
      #  Handle these specially as they are strings searched for during testing.
      ToolSubst('count.exe', unresolved='fatal'),
      ToolSubst('not.exe', unresolved='fatal')
  ]

  llvm_config.config.substitutions.append(
      ('%python', '"%s"' % (sys.executable)))