@ComponentType
        public void registerCUnitTestSuiteSpecType(TypeBuilder<CUnitTestSuiteSpec> builder) {
            builder.defaultImplementation(DefaultCUnitTestSuiteSpec.class);
        }

        @Mutate
        public void configureCUnitTestSuiteSources(@Each final CUnitTestSuiteSpec suite, @Path("buildDir") final File buildDir) {
            suite.getSources().create(CUNIT_LAUNCHER_SOURCE_SET, CSourceSet.class, new Action<CSourceSet>() {

        public void registerGoogleTestSuiteSpecTest(TypeBuilder<GoogleTestTestSuiteSpec> builder) {
            builder.defaultImplementation(DefaultGoogleTestTestSuiteSpec.class);
        }

        @ComponentType
        public void registerGoogleTestSuiteBinaryType(TypeBuilder<GoogleTestTestSuiteBinarySpec> builder) {
            builder.defaultImplementation(DefaultGoogleTestTestSuiteBinary.class);
        }

      new DslObject(p).getExtensions().getExtraProperties().set("prop", "value");
    }
}
'''
        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'

            Path buildDir =
                    project.getBuild() != null ? Paths.get(project.getBuild().getDirectory()) : null;
            if (buildDir != null) {
                Files.createDirectories(buildDir);
            }
            Path consumer = buildDir != null
                    ? Files.createTempFile(buildDir, CONSUMER_POM_CLASSIFIER + "-", ".pom")

    }

    @Test
    public void canExtendTheDefaultBuildForBuildSrcProject() {
        ArtifactBuilder builder = artifactBuilder();
        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(

        actualJar1.name == implJar.name

        when:
        builder.sourceFile('ActionImpl.java').text = """
public class ActionImpl implements ${BuildAction.name}<String> {
    public String execute(${BuildController.name} controller) {
        return getClass().getProtectionDomain().getCodeSource().getLocation().toString();
    }
}
"""
        builder.buildJar(implJar)

    Project project = ProjectBuilder.builder().build()
    ReportingExtension extension = TestUtil.newInstance(ReportingExtension.class, project)

    def "defaults to reports dir in build dir"() {
        expect:
        extension.baseDir == new File(project.buildDir, ReportingExtension.DEFAULT_REPORTS_DIR_NAME)

        when:
        project.buildDir = project.file("newBuildDir")

        then:

                    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()

class GradleProjectBuilderTest extends AbstractProjectBuilderSpec {
    def builder = new GradleProjectBuilder()

    def "builds basics for project"() {
        def buildFile = temporaryFolder.file("build.gradle") << "//empty"
        project.description = 'a test project'

        when:
        def model = builder.buildForRoot(project)

        then:
        model.path == ':'

    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        def builder = artifactBuilder()
        javaPlugin(builder.sourceFile("SneakyPlugin.java"), read)
        builder.resourceFile("META-INF/gradle-plugins/sneaky.properties") << """
implementation-class: SneakyPlugin
        """
        builder.buildJar(jar)
        buildFile << """
            plugins { id("sneaky") }
        """
    }