// If there is no top level policy and the incoming rule has top level
			// traffic policy, use the one from the incoming rule.
			if mergedRule.TrafficPolicy == nil && rule.TrafficPolicy != nil {
				mergedRule.TrafficPolicy = rule.TrafficPolicy
			}
			// If there is no exportTo in the existing rule and
			// the incoming rule has an explicit exportTo, use the
			// one from the incoming rule.

        when:
        def compile = configurationContainer.create("compile")

        then:
        compile.name == "compile"
        compile.incoming.path == ":compile"
        compile instanceof DefaultConfiguration

        and:
        configurationContainer.getByName("compile") == compile

        //finds configurations

		BlockConnect: globalGridStart,
		TLSConfig: &tls.Config{
			RootCAs:          globalRootCAs,
			CipherSuites:     fips.TLSCiphers(),
			CurvePreferences: fips.TLSCurveIDs(),
		},
		// Record incoming and outgoing bytes.
		Incoming: globalConnStats.incInternodeInputBytes,
		Outgoing: globalConnStats.incInternodeOutputBytes,
		TraceTo:  globalTrace,
	})
	if err != nil {
		return err
	}
	globalGrid.Store(g)
	return nil

            }
            task query {
                doLast {
                    assert configurations.compileClasspath.files
                    def id = configurations.compileClasspath.incoming.resolutionResult
                        .allDependencies.first().selected.id
                    dependencies.createArtifactResolutionQuery()
                        .forComponents(id)

 *
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface InternalTransformer<OUT, IN> {
    /**

.textmate

# Sublime Text
# ------------
*.sublime-*

# jEnv
# ----
.java-version

# macOS
# ----
.DS_Store

# HPROF
# -----
*.hprof

# Work dirs
# ---------
/incoming-distributions
/intTestHomeDir

# Logs
# ----
/*.log

# Thread dumps for troubleshooting
*.threaddump
# ps output for cleaning up leaking Java processes
*.psoutput

# oh-my-zsh gradle plugin

        attributes.attribute(DocsType.DOCS_TYPE_ATTRIBUTE as Attribute<DocsType>, SOURCES_ATTRIBUTE)
        extendsFrom(currentClasspath)
    }
}

def currentClasspath = configurations.currentApiClasspath.incoming.artifactView { lenient(true) }.files
def currentDistroJars = currentClasspath.filter { it.name.startsWith('gradle-') && it.name.endsWith('.jar') }
def baselineJars = configurations.baselineJars

    val projectRootDir = project.rootDir
    val pluginInfoDir = project.providers.gradleProperty("enterprisePluginInfoDir")
        .orElse(projectRootDir.resolve("incoming").path)
        .map { projectRootDir.resolve(it) }

    // Provides a system property required by `AbstractBuildScanPluginPerformanceTest`
    jvmArgumentProviders += DevelocityPluginInfoDirPropertyProvider(pluginInfoDir)
}

            }
            project(':a') {
                apply plugin: 'java'
            }
            classes.doLast {
                def components = configurations.compileClasspath.incoming.resolutionResult.allComponents.id
                assert components.size() == 2
                assert components[0].build.buildPath == ':buildSrc'
                assert components[0].build.name == 'buildSrc'

        return if (result.endsWith("/")) result else "$result/"
    }
}

with(Helper(providers)) {
    gradle.lifecycle.beforeProject {
        buildscript.configurations["classpath"].incoming.beforeResolve {
            withMirrors(buildscript.repositories)
        }
        afterEvaluate {
            withMirrors(repositories)
        }
    }

    gradle.settingsEvaluated {