t.Cleanup(func() {
		if err := check(filter); err != nil {
			t.Errorf("goroutine leak: %v", err)
		}
	})
}

// CheckMain asserts that no goroutines are leaked after a test package exits.
// This can be used with the following code:
//
//	func TestMain(m *testing.M) {
//	    leak.CheckMain(m)
//	}
//
// Failures here are scoped to the package, not a specific test. To determine the source of the failure,

        file("src/ignore-2.txt").createFile()

        run("generate")

        then:
        result.assertTaskSkipped(":generate")
        output.count("checking") == 8
        outputContains("checking a/a.txt")
        outputContains("checking ignore-2.txt")
        file("out.txt").text == "a.txt,c.txt"

        when:
        file("src/d/d.txt").createFile()
        file("src/ignore-3.txt").createFile()

	return doForward(ctx, cfg, c.e, c.makeRequest)
}

type dnsRequest struct {
	hostname  string
	dnsServer string
	query     string
	protocol  string
}

func checkIn(got string, want ...string) error {
	for _, w := range want {
		if w == got {
			return nil
		}
	}
	return fmt.Errorf("got value %q, wanted one of %v", got, want)
}

                println("checking \${it.name}")
                !it.name.contains('ignore')
            }
            task copy(type: Copy) {
                from files
                into 'dest'
            }
        """

        when:
        run 'copy'

        then:
        outputContains("checking one.txt")
        outputContains("checking ignore.txt")

        applyPlugin()

        when:
        succeeds "t", "-D${UNSUPPORTED_TOGGLE}=true"

        then:
        plugin.assertUnsupportedMessage(output, UNSUPPORTED_TOGGLE_MESSAGE)
    }

    def "checkin happens once for build with buildSrc"() {
        given:
        applyPlugin()
        file("buildSrc/src/main/groovy/Thing.groovy") << "class Thing {}"

        when:
        succeeds "t"

        then:

        return propertyWithNoValue().value(value)
    }

    def "finalization checking works empty providers"() {
        given:
        def property = propertyWithNoValue()

        expect:
        !property.isPresent()
        !property.isFinalized()
    }

    def "finalization checking works with simple values"() {
        given:
        def property = propertyWithValue(someValue())

// rundir

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The reflect package was not correctly checking field names
// when checking for struct assignability.

	
	t4 := T4{}
	t3 := T3{&t4}
	t2 := T2{&t3}
	t1 := T1{t2}
	CheckI("t4", t4, 40)
	CheckI("&t4", &t4, 40)
	CheckI("t3", t3, 40)
	CheckI("&t3", &t3, 40)
	CheckI("t2", t2, 40)
	CheckI("&t2", &t2, 40)
	CheckI("t1", t1, 40)
	CheckI("&t1", &t1, 40)
	
	// x.M panics if x is an interface type and is nil,
	// or if x.M expands to (*x).M where x is nil,

    }

    static class FileCheck extends UndeclaredFileAccess {
        private final String checkKind

        FileCheck(String filePath, String checkKind) {
            super(filePath)
            this.checkKind = checkKind
        }

        @Override
        String getKotlinExpression() {
            "File(\"${filePath}\").$checkKind()"
        }

        @Override
        String getGroovyExpression() {

// limitations under the License.

package bootstrap

import (
	"testing"

	"istio.io/istio/tests/util/leak"
)

func TestMain(m *testing.M) {
	// CheckMain asserts that no goroutines are leaked after a test package exits.
	leak.CheckMain(m)