import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;

/**
 * Generates an Eclipse <code>.classpath</code> file. If you want to fine tune the eclipse configuration
 * <p>
 * At this moment nearly all configuration is done via {@link EclipseClasspath}.
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class GenerateEclipseClasspath extends XmlGeneratorTask<Classpath> {

    The problem is that GWT responds poorly to two .gwt.xml files in the same
    Java package; see https://goo.gl/pRV3Yn for details.

    The summary is that it ignores one file in favor of the other.
    util.concurrent, like nearly all our packages, has two .gwt.xml files: one
    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

cd vend/hello
go run hello.go
stdout 'hello, world'

-- vend/hello/hello.go --
package main

import (
	"fmt"
	"strings" // really ../vendor/strings
)

func main() {
	fmt.Printf("%s\n", strings.Msg)
}
-- vend/hello/hello_test.go --
package main

import (
	"strings" // really ../vendor/strings
	"testing"
)

func TestMsgInternal(t *testing.T) {
	if strings.Msg != "hello, world" {

    The problem is that GWT responds poorly to two .gwt.xml files in the same
    Java package; see https://goo.gl/pRV3Yn for details.

    The summary is that it ignores one file in favor of the other.
    util.concurrent, like nearly all our packages, has two .gwt.xml files: one
    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

// happen immediately.
func New(name, text string) *Template {
	lt := &Template{name: name, text: text}
	if inTest {
		// In tests, always parse the templates early.
		lt.tp()
	}
	return lt

            }
        """
        build1.settingsFile << """
            includeBuild("../${build2.buildName}")
        """

        then:
        succeeds()
    }

    def "can nest early included plugin builds"() {
        when:
        settingsFile << """
            pluginManagement {
                includeBuild("${build1.buildName}")
            }
            plugins {

        def initScript = file("init.gradle") << """
            rootProject { root ->
                if (root.state.executed) {
                    throw new IllegalStateException("Root project should not be evaluated too early")
                }
            }
        """
        when:
        withConnection { ProjectConnection connection ->

    The problem is that GWT responds poorly to two .gwt.xml files in the same
    Java package; see https://goo.gl/pRV3Yn for details.

    The summary is that it ignores one file in favor of the other.
    util.concurrent, like nearly all our packages, has two .gwt.xml files: one
    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

// This is an API usage error - the local side is closed.
// ErrPersistEOF (above) reports that the remote side is closed.
var errClosed = errors.New("i/o operation on closed connection")

// ServerConn is an artifact of Go's early HTTP implementation.
// It is low-level, old, and unused by Go's current HTTP stack.
// We should have deleted it before Go 1.
//
// Deprecated: Use the Server in package [net/http] instead.
type ServerConn struct {

Continuous improvement combined with frequent delivery allows new features to be available to users early.
Early users provide invaluable feedback, which is incorporated into the development process.

Getting new functionality into the hands of users regularly is a core value of the Gradle platform.