// Make sure we have sufficient privilege to run mklink command.
	testenv.MustHaveSymlink(t)

	file := filepath.Join(tmpdir, "file")
	err = os.WriteFile(file, []byte(""), 0666)
	if err != nil {
		t.Fatal(err)
	}

	target = filepath.Join(target, file[len(filepath.VolumeName(file)):])

	filelink := filepath.Join(tmpdir, "filelink")
	output, err = exec.Command("cmd", "/c", "mklink", filelink, target).CombinedOutput()

    }

    public String toLineString() {
        if (isUpdated()) {
            return StringUtils.join(newInputs, ",") + "=>" + newOutput;
        }
        return StringUtils.join(inputs, ",") + "=>" + output;
    }

	}
	return strings.Split(path, string(ListSeparator))
}

func abs(path string) (string, error) {
	return unixAbs(path)
}

func join(elem []string) string {
	// If there's a bug here, fix the logic in ./path_plan9.go too.
	for i, e := range elem {
		if e != "" {
			return Clean(strings.Join(elem[i:], string(Separator)))
		}
	}
	return ""
}

func sameWord(a, b string) bool {
	return a == b

  }

  public void testJoin() {
    assertThat(join()).isEmpty();
    assertThat(join(1)).isEqualTo("1");
    assertThat(join(1, 2)).isEqualTo("1,2");
    assertThat(join(-1, Integer.MIN_VALUE)).isEqualTo("4294967295,2147483648");

    assertThat(UnsignedInts.join("", 1, 2, 3)).isEqualTo("123");
  }

  private static String join(int... values) {
    return UnsignedInts.join(",", values);
  }

  @J2ktIncompatible

		log.Fatal(err)
	}
	goroot = filepath.Join(cwd, "../../../../..")

	// Copy testdata into GOPATH/src/testplugin, along with a go.mod file
	// declaring the same path.

	GOPATH, err := os.MkdirTemp("", "plugin_test")
	if err != nil {
		log.Panic(err)
	}
	defer os.RemoveAll(GOPATH)
	tmpDir = GOPATH
	fmt.Printf("TMPDIR=%s\n", tmpDir)

	modRoot := filepath.Join(GOPATH, "src", "testplugin")

			"ingressIP":  "fd00:10:96::2",
		},
	}
	for _, dir := range files {
		if !dir.IsDir() {
			continue
		}
		testdir := path.Join("testdata/vmconfig", dir.Name())
		t.Cleanup(func() {
			for k := range generated {
				os.Remove(path.Join(testdir, k))
			}
		})
		t.Run(dir.Name(), func(t *testing.T) {
			createClientFunc := func(client kube.CLIClient) {

${modules.toSorted().collect {"$it=$lockFileId"}.join('\n')}
empty=
""".denormalize()
        } else {
            lockDir.file("${lockFileId}.lockfile") << """${LockFileReaderWriter.LOCKFILE_HEADER_LIST.join('\n')}
${modules.toSorted().join('\n')}
""".denormalize()
        }
    }

		for _, pkg := range pkgs {
			pkgpath := path.Join("test", strings.TrimSuffix(pkg.files[0], ".go"))
			cfg += "\npackagefile " + pkgpath + "=" + filepath.Join(tempDir, pkgpath+".a")
		}
		filename := filepath.Join(tempDir, "importcfg")
		err := os.WriteFile(filename, []byte(cfg), 0644)
		if err != nil {
			t.Fatal(err)
		}
		return filename
	}

	long := filepath.Join(t.gorootTestDir, t.goFileName())
	switch action {

	dir := t.TempDir()

	const prog = `
package main

import "net"

func main() {
	net.Dial("", "")
}
`
	src := filepath.Join(dir, "issue33358.go")
	if err := os.WriteFile(src, []byte(prog), 0666); err != nil {
		t.Fatal(err)
	}

	binFile := filepath.Join(dir, "issue33358")
	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-o", binFile, src)
	if out, err := cmd.CombinedOutput(); err != nil {

import org.gradle.test.fixtures.file.TestFile

trait GroovyPluginImplementation {
    void groovyDsl(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            println("apply = " + ${read.groovyExpression})
            tasks.register("thing") {
                doLast {
                    println("task = " + ${read.groovyExpression})
                }