What if one subproject depends on another subproject?
What if one project needs the artifact produced by another project?

image::structuring-builds-2.png[]

This is a common use case for multi-project builds.
Gradle offers <<declaring_dependencies.adoc#sub:project_dependencies,project dependencies>> for this.

[[sec:project_jar_dependencies]]
== Depending on another project

stdout cmd/nm
! stdout cmd/internal/goobj pkglist.txt

# ... now collect a coverage profile from a Go file
# listed on the command line.
go build -cover -o $WORK/another.exe testdata/another.go
mkdir $WORK/covdata2
env GOCOVERDIR=$WORK/covdata2
exec $WORK/another.exe 

# Restore previous GOCOVERDIR setting
env GOCOVERDIR=$SAVEGOCOVERDIR

# Check to make sure we instrumented just the main package.

git branch v2.3.4

at 2018-04-17T16:00:19-04:00
echo 'intermediate'
cp stdout foo.txt
git add foo.txt
git commit -a -m 'intermediate'

at 2018-04-17T16:00:32-04:00
echo 'another'
cp stdout another.txt
git add another.txt
git commit -a -m 'another'
git tag v2.0.2

at 2018-04-17T16:16:52-04:00
git checkout master
git branch v3
git checkout v3
mkdir v3/sub/dir
echo 'v3/sub/dir/file'
cp stdout v3/sub/dir/file.txt

	wi3 := &model.WorkloadInstance{
		Name:      "another-ip",
		Namespace: selector.Namespace,
		Endpoint: &model.IstioEndpoint{
			Address: "3.3.3.3",
			Labels:  map[string]string{"app": "another-wle"}, // should not match because of another label
		},
	}

	wi4 := &model.WorkloadInstance{
		Name:      "another-name",
		Namespace: "another-namespace", // should not match because of another namespace
		Endpoint: &model.IstioEndpoint{

package modindex

import (
	"go/build"
	"runtime"
	"testing"
)

var (
	thisOS    = runtime.GOOS
	thisArch  = runtime.GOARCH
	otherOS   = anotherOS()
	otherArch = anotherArch()
)

func anotherOS() string {
	if thisOS != "darwin" && thisOS != "ios" {
		return "darwin"
	}
	return "linux"
}

func anotherArch() string {
	if thisArch != "amd64" {
		return "amd64"
	}

        assertGrammarSourceGenerated("Another")
        assertAntlrVersion(4)
        succeeds("build")
    }

    def "can import grammar from root antlr source folder"() {
        goodGrammar()
        file("grammar-builder/src/main/antlr/GrammarWithImport.g4") << """grammar GrammarWithImport;
            import Another;
            r  : 'hello' ID ;
            ID : [a-z]+ ;

// license that can be found in the LICENSE file.

package build

import (
	"runtime"
	"testing"
)

var (
	thisOS    = runtime.GOOS
	thisArch  = runtime.GOARCH
	otherOS   = anotherOS()
	otherArch = anotherArch()
)

func anotherOS() string {
	if thisOS != "darwin" && thisOS != "ios" {
		return "darwin"
	}
	return "linux"
}

func anotherArch() string {
	if thisArch != "amd64" {
		return "amd64"
	}

            requires another;
        }
        '''
        file("src/main/java/example/io/example/Example.java") << '''
            package io.example;

            import io.another.BaseExample;

            public class Example extends BaseExample {}
        '''
        file("src/main/moreJava/another/module-info.java") << 'module another { exports io.another; }'

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	bad "issue47185.dir/bad"
)

func main() {
	another()
	bad.Bad()
}

func another() L {
	m := make(map[string]L)
	return m[""]
}

type L struct {
	A Data
	B Data
}

type Data struct {
	F1 [22][]string

class TargetType {
    var foo = ""
    fun name(s: String, i: Int, a: Any) {}
    fun blockName(closure: groovy.lang.Closure<*>) {}
    fun another(map: Map<String, *>) {}
}


val target = TargetType()
val aReference = ""

// tag::withGroovyBuilder[]
target.withGroovyBuilder {                                          // <1>

    // GroovyObject methods available                               // <2>