------------------------------------------------------------

DocumentationComponent 'docs'
-----------------------------

Source sets
    Markdown source 'docs:userguide'
        srcDir: src/docs/userguide
    Text source 'docs:reference'
        srcDir: src/docs/reference

Binaries
    DocumentationBinary 'docs:exploded'
        build using task: :docsExploded

            } else {
                for (File srcDir : fileCollectionFactory.resolving(path)) {
                    if (!srcDir.isDirectory() && srcDir.exists()) {
                        throw new InvalidUserDataException(String.format("Source directory '%s' is not a directory.", srcDir));
                    }
                    result.add(directoryFileTreeFactory.create(srcDir, patterns));
                }
            }
        }

        outputMatches """
Native library 'someLib'
------------------------

Source sets
    Assembler source 'someLib:asm'
        srcDir: src/someLib/asm
    C source 'someLib:c'
        srcDir: src/someLib/c
    C++ source 'someLib:cpp'
        srcDir: src/someLib/cpp

Binaries
    Shared library 'someLib:amd64:free:sharedLibrary'
        build using task: :someLibAmd64FreeSharedLibrary

        file('build.gradle').text = '''
apply plugin: 'java'
apply plugin: 'eclipse'

sourceSets {
    main {
        java { srcDir 'src' }
        resources { srcDir 'src' }
    }

    test {
        java { srcDir 'test' }
        resources { srcDir 'testResources' }
    }
}
'''
        //if we don't create the folders eclipse plugin will not build the classpath
        projectDir.create {

        _ * sourceDirectorySet.excludes >> []

        when:
        renderer.render(languageSourceSet, builder)

        then:
        output.value.contains("""
srcDir: src/folder1
srcDir: src/folder2
""")
    }

    def "shows includes / excludes"() {
        given:
        1 * sourceDirectorySet.includes >> includes
        1 * sourceDirectorySet.excludes >> excludes

        }
        resources {
            srcDirs = ['src/resources']
        }
    }
// end::define-main[]
    test {
        java {
            srcDir 'test/java'
        }
        resources {
            srcDir 'test/resources'
        }
    }
// tag::define-main[]
}

	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:

        if (os.isWindows()) {
            File jreDir;
            if (javaVersionMajor == 5) {
                jreDir = new File(javaHome.getParentFile(), "jre" + implementationJavaVersion);
            } else {
                jreDir = new File(javaHome.getParentFile(), "jre" + javaVersionMajor);
            }
            if (jreDir.isDirectory()) {
                return jreDir;
            }
        }
        return null;