if isStandard {
		return imp
	}

	if strings.HasPrefix(srcDir, filepath.Join(goroot, "src", "cmd")) {
		return path.Join("cmd", "vendor", imp)
	} else if strings.HasPrefix(srcDir, filepath.Join(goroot, "src")) {
		return path.Join("vendor", imp)
	} else {
		panic(fmt.Sprintf("srcDir %q not in GOOROT/src", srcDir))
	}

}

// Create creates a gzipped tar file from srcDir and writes it to outPath.
func Create(srcDir, outPath string) error {
	mw, err := os.Create(outPath)
	if err != nil {
		return err
	}
	defer mw.Close()
	gzw := gzip.NewWriter(mw)
	defer gzw.Close()

	tw := tar.NewWriter(gzw)
	defer tw.Close()

	return filepath.Walk(srcDir, func(file string, fi os.FileInfo, err error) error {
		if err != nil {

                inputFiles.from($fileTree.$pattern)
            }
        """
        def srcDir = createDir('src') {
            file('foo.ok').write('')
            file('foo.fail').write('')
        }
        if (isZip) {
            srcDir.zipTo(file('src.zip'))
        }

        and:
        def configurationCache = newConfigurationCacheFixture()

        when:

    testImplementation 'junit:junit:4.7'
}

sourceSets {
    integTest {
        java.srcDirs = ['src/integTest/java']
    }
    main {
        java.srcDir 'src/main/testbutnottest'
    }
    test {
        java.srcDir 'src/test/t_e_s_t'
    }

apply plugin: 'c'

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                library(CSourceSet) {
                    source.srcDir "src/library/c"
                    exportedHeaders.srcDir "src/library/headers"
                }
                c.lib library
            }
        }
    }
}
"""
        when:
        succeeds "mainExecutable"

        then:

                        platformWindows(CSourceSet) {
                            source.srcDir "src/main/windows"
                            lib m.sources.c
                        }
                    } else if (targetPlatform.operatingSystem.linux) {
                        platformLinux(CSourceSet) {
                            source.srcDir "src/main/linux"
                            lib m.sources.c
                        }

        executable file: build/exe/someExe/someExe

Cunit test suite 'someExeTest'
------------------------------

Source sets
    C source 'someExeTest:c'
        srcDir: src/someExeTest/c
    C source 'someExeTest:cunitLauncher'
        srcDir: build/src/someExeTest/cunitLauncher/c

Binaries
    C unit exe 'someExeTest:cUnitExe'
        build using task: :someExeTestCUnitExe

}
model {
    buildTypes {
        debug
        release
    }
    repositories {
        libs(PrebuiltLibraries) {
            boost {
                headers.srcDir "3rd-party-lib/boost_1_55_0/boost"
            }
            util {
                headers.srcDir "3rd-party-lib/util/src/util/headers"
                binaries.withType(StaticLibraryBinary) {

            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(
                            JavaVersionsToIncubatingCollector(srcDir),
                            KotlinVersionsToIncubatingCollector()
                        )

        given:
        buildFile << """
model {
    components {
        main {
            sources {
                other(CppSourceSet) {
                    source.srcDir "src/other/cpp"
                }
            }
            binaries.all {
                lib library: 'lib1', linkage: 'static'
            }
        }
    }
}
"""
        when: