when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':b1:logProject')
    }
"""

        execute(buildA, ":delegate")

        then:
        executed ":buildB:b1:logProject"
        output.contains("Executing build 'buildB' project ':b1' task ':b1:logProject'")
    }

    def "can depend on multiple tasks of included build"() {
        when:

00000150  7e b1 27 b1 79 44 ef 79  95 51 75 02 24 2c ea ab  |~.'.yD.y.Qu.$,..|
00000160  d5 e1 fd aa 81 55 89 cf  bc 9c 11 2b 0b 4a 99 9f  |.....U.....+.J..|
00000170  50 93 68 a1 c8 79 3d d8  aa d8 54 e3 d5 1a 97 90  |P.h..y=...T.....|
00000180  33 87 a9 70 1d 9d ba 78  d0 87 8a 98 6f 1b 1e b0  |3..p...x....o...|
00000190  e8 92 78 df 21 61 88 36  fa 14 4b c9 b1 a4 93 88  |..x.!a.6..K.....|

	return (&printer.Config{Mode: printerMode, Tabwidth: tabWidth}).Fprint(src, fset, f)
}

func testFile(t *testing.T, b1, b2 *bytes.Buffer, filename string) {
	// open file
	f, err := os.Open(filename)
	if err != nil {
		t.Error(err)
		return
	}

	// read file
	b1.Reset()
	_, err = io.Copy(b1, f)
	f.Close()
	if err != nil {
		t.Error(err)
		return
	}

		{MakePos(b1, 1, 1), MakePos(b1, 1, 1), true, false, false},
		{MakePos(b1, 1, 1), MakePos(b1, 1, 2), true, true, false},
		{MakePos(b1, 1, 2), MakePos(b1, 1, 1), true, false, true},
		{MakePos(b1, 123, 1), MakePos(b1, 1, 123), true, false, true},

		{MakePos(b1, 1, 1), MakePos(b2, 1, 1), true, true, false},
		{MakePos(b1, 1, 1), MakePos(b2, 1, 2), true, true, false},

	x uint8
}
type T2 struct {
	x uint16
}
type T4 struct {
	x uint32
}

func main() {
	report := len(os.Args) > 1
	status := 0
	var b1 [10]T1
	a0, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[0])[2:], 16, 64)
	a1, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[1])[2:], 16, 64)
	if a1 != a0+1 {
		fmt.Println("FAIL")
		if report {
			fmt.Println("alignment should be 1, is", a1-a0)
		}
		status = 1
	}

    return (int) in.skip(n);
  }

  @CanIgnoreReturnValue // to skip a byte
  @Override
  public int readUnsignedByte() throws IOException {
    int b1 = in.read();
    if (0 > b1) {
      throw new EOFException();
    }

    return b1;
  }

  /**
   * Reads an unsigned {@code short} as specified by {@link DataInputStream#readUnsignedShort()},
   * except using little-endian byte order.
   *

		m := make(map[io.Reader]io.Writer)
		mv := ValueOf(m)
		b1 := new(bytes.Buffer)
		b2 := new(bytes.Buffer)
		mv.SetMapIndex(ValueOf(b1), ValueOf(b2))
		x, ok := m[b1]
		if x != b2 {
			t.Errorf("#5 after SetMapIndex(b1, b2): %p (!= %p), %t (map=%v)", x, b2, ok, m)
		}
		if p := mv.MapIndex(ValueOf(b1)).Elem().UnsafePointer(); p != unsafe.Pointer(b2) {
			t.Errorf("#5 MapIndex(b1) = %#x want %p", p, b2)
		}
	}
	{

        def dir1 = tmpDir.createDir("b1")
        def dir2 = tmpDir.createDir("other/b1")
        def dir3 = tmpDir.createDir("other2/b1")
        def buildDefinition1 = build(dir1, "b1")
        def buildDefinition2 = build(dir2, "b2")
        def buildDefinition3 = build(dir3, "b3")
        def includedBuild1 = expectIncludedBuildAdded("b1", buildDefinition1)

	b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoSyscall)
	b0.Event("GoSyscallEndBlocked")

	// A bare M stole the goroutine's P at the generation boundary.
	b1 := g.Batch(trace.ThreadID(1), 0)
	b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)
	b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(0))

			return x
		}
	}
	return nil
}

var sink *uint64

func main() {
	var a1, a2 A
	var b1, b2, b3, b4 B
	var x1, x2, x3, x4 uint64 // ERROR "moved to heap: x1" "moved to heap: x3"
	b1.b[0] = &x1
	b2.b[0] = &x2
	b3.b[0] = &x3
	b4.b[0] = &x4
	f(a1)
	g(&a2)
	sink = h(&b1)
	h(&b2)
	sink = h2(&b1)
	h2(&b4)
	x1 = 17
	println("*sink=", *sink) // Verify that sink addresses x1
	x3 = 42
	sink = k(b3)