println "root: " + doSomethingElse(10)
"""
        file("child1/build.gradle") << """
println "child: " + doSomething(11)
println "child: " + doSomethingElse(11)
"""

        expect:
        // Invoke twice to exercise script caching
        succeeds()
        outputContains("root: {10}")
        outputContains("root: [10]")
        outputContains("child: {11}")
        outputContains("child: [11]")

        and:

func TestEncodeDecodemetacache(t *testing.T) {
	v := metacache{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodemetacache Msgsize() is inaccurate")
	}

	vn := metacache{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}

fun test() {
    val f = String::length
    val s = "hello"
    val g = s::length
    f(s) + g() + String::length.invoke(s) + <expr>s::length</expr>.invoke()

     */
    void writeByte(byte value) throws IOException;

    /**
     * Writes the given raw bytes to the stream. Does not encode any length information.
     */
    void writeBytes(byte[] bytes) throws IOException;

    /**
     * Writes the given raw bytes to the stream. Does not encode any length information.
     */
    void writeBytes(byte[] bytes, int offset, int count) throws IOException;

    /**

fun test() {
    val f = <expr>String::length</expr>
    val s = "hello"
    val g = s::length</expr>
    f() + g() + String::length.invoke(s) + s::length.invoke()

fun test() {
    val f = String::length
    val s = "hello"
    val g = <expr>s::length</expr>
    f(s) + g() + String::length.invoke(s) + s::length.invoke()

fun test() {
    val f = String::length
    val s = "hello"
    val g = s::length
    f(s) + <expr>g</expr>() + String::length.invoke(s) + s::length.invoke()

    }

    /**
     * The character set used to encode JAR metadata like file names.
     * Defaults to UTF-8.
     * You can change this property but it is not recommended as JVMs expect JAR metadata to be encoded using UTF-8
     *
     * @return the character set used to encode JAR metadata like file names
     * @since 2.14
     */
    @Override

		t.Errorf("Could not encode a %v: %s", kind, err)
		return
	}

	// Refuzz the copy, which should have no effect on the original
	f.Fuzz(itemCopy)

	postfuzzData := &bytes.Buffer{}
	if err := legacyscheme.Codecs.LegacyCodec(kind.GroupVersion()).Encode(item, postfuzzData); err != nil {
		t.Errorf("Could not encode a %v: %s", kind, err)
		return
	}

fun test() {
    val f = <expr>String</expr>::length
    val s = "hello"
    val g = s::length
    f() + g() + String::length.invoke(s) + s::length.invoke()