Task ideTask = project.tasks['testIde']
        ideTask.taskDependencies.getDependencies(ideTask) == [worker] as Set

        Task cleaner = project.tasks['cleanGenerateXml']
        cleaner instanceof Delete
    }
}

class TestIdePlugin extends IdePlugin {
    @Override protected String getLifecycleTaskName() {
        return 'testIde'
    }

    @Override protected void onApply(Project target) {

 */

package org.gradle.plugins.ide.internal

import org.gradle.api.Project

class TestIdePlugin extends IdePlugin {
    @Override protected String getLifecycleTaskName() {
        return 'testIde'
    }

    @Override protected void onApply(Project target) {
        def worker = target.task('generateXml')
        addWorker(target.getTasks().named(worker.getName()), worker.getName());
    }

        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 --

	"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)