*/
class CompositeBuildConfigurationTimeResolveIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    BuildTestFile buildB
    BuildTestFile buildC

    MavenModule publishedModuleB
    TestFile buildBjar

    def setup() {
        publishedModuleB = mavenRepo.module("org.test", "buildC", "1.0").publish()

        buildA.buildFile << """
            println "Configured buildA"
            task resolve(type: Copy) {

           tasks.register("buildBJar") {
                dependsOn(gradle.includedBuild("buildB").task(":jar"))
            }
        """
        buildA.settingsFile << """
            includeBuild('.')
        """

        includeBuild(buildB)
        dependency(buildB, "org.test:buildA")

        when:
        execute(buildA, "buildBJar")

        then:

            sourceFile("org/gradle/test/BuildClass.java").text = buildClassSource
            buildJar(reproducibleJar)
        }
        artifactBuilder().tap {
            preserveTimestamps(true)
            sourceFile("org/gradle/test/BuildClass.java").text = buildClassSource
            buildJar(currentTimestampJar)
        }

        Closure<String> subprojectSource = {File jarPath -> """

        builder.sourceFile("org/gradle/test/DepClass.java").writelns(
                "package org.gradle.test;",
                "public class DepClass { }"
        );
        builder.buildJar(testFile("repo/test-1.3.jar"));

        testFile("buildSrc/build.gradle").writelns(
                "repositories { flatDir { dirs '../repo' } }",
                "dependencies { implementation name: 'test', version: '1.3' }");

        this.inPlaceBuilder = new InPlaceClasspathBuilder();
    }

    @Override
    public void jar(File jarFile, Action action) {
        try {
            buildJar(jarFile, action);
        } catch (Exception e) {
            throw new GradleException(String.format("Failed to create Jar file %s.", jarFile), e);
        }
    }

    @Override

        } catch (java.net.URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }
}
"""
        builder.buildJar(implJar)

        def cl1 = new URLClassLoader([implJar.toURI().toURL()] as URL[], getClass().classLoader)
        def action1 = cl1.loadClass("ActionImpl").getConstructor().newInstance()

        when:

    }
}
'''
        builder.resourceFile('META-INF/gradle-plugins/custom.properties') << '''
implementation-class=CustomPlugin
'''
        builder.buildJar(file('external.jar'))

        and:
        file('build.gradle') << '''
buildscript {
    dependencies {
        classpath files('external.jar')
    }
}
apply plugin: 'custom'
assert 'value' == prop

    TestFile sourceFile(String path);

    TestFile resourceFile(String path);

    void manifestAttributes(Map<String, String> attributes);

    void preserveTimestamps(boolean preserveTimestamps);

    void buildJar(File jarFile);

    @Override
    public void jar(File jarFile, Action action) {
        try {
            buildJar(jarFile, action);
        } catch (Exception e) {
            throw new GradleException(String.format("Failed to create Jar file %s.", jarFile), e);
        }
    }

    private static void buildJar(File jarFile, Action action) throws IOException {
        Files.createDirectories(jarFile.getParentFile().toPath());

                    return null;
                }
            }
        """
        def jar = temporaryFolder.file("work folder", "action-impl.jar")
        builder.buildJar(jar)

        when:
        def classloader = new URLClassLoader([jar.toURL()] as URL[], getClass().classLoader)
        def action = classloader.loadClass("ActionImpl").getConstructor().newInstance()