succeeds("assemble")
        assertRepoNotCheckedOut()
    }

    @ToBeFixedForConfigurationCache
    def "last vcs mapping rule wins"() {
        mappingFor("does-not-exist", "org.test:dep")
        mappingFor(repo, "org.test:dep")
        expect:
        succeeds("assemble")
        assertRepoCheckedOut()
    }

    @ToBeFixedForConfigurationCache

package main
import "testing"
func TestNopgo(*testing.T) {}
-- dep/dep.go --
package dep
import _ "test/dep3"
-- dep2/dep2.go --
package dep2
-- dep3/dep3.go --
package dep3
-- testdep/testdep.go --
package testdep
import _ "test/testdep2"
-- testdep2/testdep2.go --

# Plugins are not supported on all platforms.
[!buildmode:plugin] skip

go build -n testdep
! go build -buildmode=plugin testdep
stderr '-buildmode=plugin requires exactly one main package'

-- go.mod --
module testdep

go 1.16
-- testdep.go --

	testPod := st.MakePod().Name("foo").Namespace("ns").Obj()
	testNode := "foohost.kubernetes.mydomain.com"
	tests := []struct {
		name        string
		injectErr   error
		wantBinding *v1.Binding
	}{
		{
			name: "successful",
			wantBinding: &v1.Binding{
				ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: "foo"},
				Target:     v1.ObjectReference{Kind: "Node", Name: testNode},
			},
		}, {
			name:      "binding error",

	"internal/testenv"
	"os"
	"strings"
	"testing"
)

func TestCheckFDs(t *testing.T) {
	if *flagQuick {
		t.Skip("-quick")
	}

	testenv.MustHaveGoBuild(t)

	fdsBin, err := buildTestProg(t, "testfds")
	if err != nil {
		t.Fatal(err)
	}

	i, err := os.CreateTemp(t.TempDir(), "fds-input")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := i.Write([]byte("stdin")); err != nil {
		t.Fatal(err)
	}

    private final Set<String> testIds = new HashSet<>();

    public CompositeDataReporter(List<DataReporter<CrossVersionPerformanceResults>> reporters) {
        this.reporters = reporters;
    }

    @Override
    public void report(CrossVersionPerformanceResults results) {
        if (!testIds.add(results.getTestId())) {

        resolve.expectDefaultConfiguration("runtime")
        resolve.expectGraph {
            root(":", ":test:") {
                edge("org.test:child:1.0", "org.test:child:1.0") {
                    edge("org.test:dep:2.1", "org.test:dep:2.1")
                }
            }
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/1898")
    def "can resolve pom importing version range"() {
        given:

import org.junit.Before;

import static org.junit.Assert.assertEquals;

public class PersonTest{

    Person person;
    @Before public void setup(){
        person = new Person();
    }

    @Test public void testAge() {
        person.setAge(30);
        assertEquals(30, person.getAge());
    }


    @Test public void testSurname() {
        person.setSurname("Duke");
        assertEquals("Duke", person.getSurname());

    }

    @ToBeFixedForConfigurationCache(because = "testkit jar generated eagerly")
    def "gradle testkit jar is generated only when requested"() {
        setup:
        testCode()

        def version = distribution.version.version
        def generatedJarsDirectory = "user-home/caches/$version/generated-gradle-jars"

        when:
        succeeds("classes")

        then:

		},
	}
	for i := range tests {
		tt := &tests[i]
		t.Run(tt.name, func(t *testing.T) {
			testNode := &model.Proxy{
				Labels: map[string]string{
					"app": "foo",
				},
				Metadata: &model.NodeMetadata{},
			}

			got := BuildInboundTLS(model.MTLSStrict, testNode, networking.ListenerProtocolTCP, []string{}, tls.TlsParameters_TLSv1_2, &tt.mesh)