}
            }
        """)

        when:
        succeeds "pluginTask"

        then:
        output.contains("I'm here")
    }
    def "can use dynamic versions and status to depend on snapshot version"() {
        given:
        publishTestPlugin("1.1-SNAPSHOT", "from 1.1")
        publishTestPlugin("1.2", "from 1.2")
        useCustomRepository()

        buildFile << """

package syntax

import "go/constant"

// A Type represents a type of Go.
// All types implement the Type interface.
// (This type originally lived in types2. We moved it here
// so we could depend on it from other packages without
// introducing an import cycle.)
type Type interface {
	// Underlying returns the underlying type of a type.
	// Underlying types are never Named, TypeParam, or Alias types.
	//

		t.Skipf("skipping because the toolchain does not have to bootstrap on GOOS=%s", runtime.GOOS)
	}

	realGoroot := testenv.GOROOT(t)

	// To ensure that bootstrapping doesn't unexpectedly depend
	// on the Go repo's git metadata, add a fake (unreadable) git
	// directory above the simulated GOROOT.
	// This mimics the configuration one much have when
	// building from distro-packaged source code

 4. Updating task dependencies.
+
`compileJava` must depend on `prepare`, `package` must depend on `compileJava` rather than `ant_build`, and `assemble` must depend on `package` rather than the standard Gradle `jar` task.

    }

    /**
     * Test two projects (:a and :b) depending on plugins from the same two included builds (:plugin-1 and :plugin-2)
     * which in turn depend on a plugin from another included build (:plugin-0).
     *
     * In addition, projects :a and :b also depend on the :plugins build for the model building plugin.
     **/

class SwiftDependenciesCppInteroperabilityIntegrationTest extends AbstractSwiftMixedLanguageIntegrationTest {
    def app = new SwiftAppWithCppLibrary()

    @ToBeFixedForConfigurationCache
    def "can depend on both swift and cpp libraries from VCS"() {
        given:
        createDirs("app")
        settingsFile << """
            include 'app'

            sourceControl {
                vcsMappings {

// Here be dragons.

package main

import "runtime"

func main() {
	test1()
	test2()
	test3()
	test4()
	test5()
	test6()
	test7()
}

func die() {
	runtime.Breakpoint()	// can't depend on panic
}

func mustRecover(x interface{}) {
	mustNotRecover()	// because it's not a defer call
	v := recover()
	if v == nil {
		println("missing recover")
		die()	// panic is useless here
	}
	if v != x {

 * contextual module to provide declarations differently, such as providing alternative declarations for an outsider module. Some
 * functionality such as package set computation may also depend on the contextual module, as the declaration provider may require
 * additional information not available in the [scope].
 */

        when:
        succeeds ":app:installRelease"
        then:
        assertTasksExecutedFor("Release")
        assertAppHasOutputFor("release")
    }

    @ToBeFixedForConfigurationCache
    def "can depend on swift libraries from VCS"() {
        given:
        createDirs("app")
        settingsFile << """
            include 'app'

            sourceControl {
                vcsMappings {

 * purpose of this class is to track dependencies between projects as they are resolved. By knowing which
 * project is making the request, we can determine which projects depend on which other projects.
 */
public class DefaultLocalComponentRegistry implements LocalComponentRegistry {
    private final Path currentProjectPath;
    private final Path currentBuildPath;