// Assigning registered tasks to a variable in Groovy

def hello = tasks.register('hello') {
    doLast {
        println 'hello'
    }
}

def copy = tasks.register('copy', Copy) {
    from(file('srcDir'))
    into(buildDir)

	return m.ImportFrom(path, "" /* no vendoring */, 0)
}

func (m *gcimports) ImportFrom(path, srcDir string, mode types2.ImportMode) (*types2.Package, error) {
	if mode != 0 {
		panic("mode must be 0")
	}
	return gcimporter.Import(m.packages, path, srcDir, m.lookup)

            new File(genDir, "org.gradle.build.gen${i}.properties").text = "implementation-class=org.gradle.build.generated.GeneratedPlugin${i}"
        }
    }
}

sourceSets.main.java.srcDir 'build/src/generated/java'
sourceSets.main.resources.srcDir 'build/src/generated/resources'

tasks.named('compileJava').configure {
    dependsOn 'generatePluginSources'
}

tasks.named('processResources').configure {

        then:
        javaClassFile("org/test/JavaClazz.class").exists()
        where:
        forkMode << [true, false]
    }

    private writeJavaTestSource(String srcDir) {
        file(srcDir, 'org/test/JavaClazz.java') << """
            package org.test;
            public class JavaClazz {
                public static void main(String... args){

                }
            }

func (p *Importer) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) {
	if mode != 0 {
		panic("non-zero import mode")
	}

	if abs, err := p.absPath(srcDir); err == nil { // see issue #14282
		srcDir = abs
	}
	bp, err := p.ctxt.Import(path, srcDir, 0)
	if err != nil {
		return nil, err // err may be *build.NoGoError - return as is
	}

// Using Kotlin delegated properties

val hello by tasks.registering {
    doLast {
        println("hello")
    }
}

val copy by tasks.registering(Copy::class) {
    from(file("srcDir"))
    into(buildDir)

	return m.ImportFrom(path, "" /* no vendoring */, 0)
}

func (m *gcimports) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) {
	if mode != 0 {
		panic("mode must be 0")
	}
	return gcimporter.Import(m.fset, m.packages, path, srcDir, m.lookup)
}

// gccgo importer

type gccgoimports struct {
	packages map[string]*types.Package

            "my.own.plugin" to "my.own.Plugin"
        )

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        // when:
        withSynchronousIO {
            buildPluginDependencySpecAccessorsFor(
                pluginDescriptorsClassPath = classPathOf(pluginsJar),
                srcDir = srcDir,
                binDir = binDir
            )
        }

        // then:

        buildFile << """
apply plugin: 'cunit-test-suite'

model {
    repositories {
        libs(PrebuiltLibraries) {
            cunit {
                headers.srcDir "${prebuiltPath}/cunit/2.1-2/include"
                binaries.withType(StaticLibraryBinary) {
                    staticLibraryFile = file("${prebuiltPath}/cunit/2.1-2/lib/${toolChain.unitTestPlatform}/${cunitLibName}")

        buildFile << """
apply plugin: 'google-test-test-suite'

model {
    repositories {
        libs(PrebuiltLibraries) {
            googleTest {
                headers.srcDir "${prebuiltPath}/googleTest/1.7.0/include"
                binaries.withType(StaticLibraryBinary) {
                    staticLibraryFile = file("${prebuiltPath}/googleTest/1.7.0/lib/${toolChain.unitTestPlatform}/${googleTestLib}")