//	writing to buf; w is index of next byte to write.
	//	dotdot is index in buf where .. must stop, either because
	//		it is the leading slash or it is a leading ../../.. prefix.
	n := len(path)
	out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen}
	r, dotdot := 0, 0
	if rooted {
		out.append(Separator)
		r, dotdot = 1, 1
	}

	for r < n {
		switch {
		case IsPathSeparator(path[r]):

	//	reading from path; r is index of next byte to process.
	//	writing to buf; w is index of next byte to write.
	//	dotdot is index in buf where .. must stop, either because
	//		it is the leading slash or it is a leading ../../.. prefix.
	out := lazybuf{s: path}
	r, dotdot := 0, 0
	if rooted {
		out.append('/')
		r, dotdot = 1, 1
	}

	for r < n {
		switch {
		case path[r] == '/':
			// empty path element
			r++

	{"http://foo.com/bar/baz", "quux/./dotdot/dotdot/dotdot/./../../.././././tail", "http://foo.com/bar/quux/tail"},
	{"http://foo.com/bar/baz", "quux/./dotdot/../dotdot/../dot/./tail/..", "http://foo.com/bar/quux/dot/"},

	// Remove any dot-segments prior to forming the target URI.
	// https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4

	cwd, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}

	cases := []struct {
		name string
		dir  string
		want string
	}{
		{"empty", "", cwd},
		{"dot", ".", cwd},
		{"dotdot", "..", filepath.Dir(cwd)},
		{"PWD", cwd, cwd},
		{"PWDdotdot", cwd + string(filepath.Separator) + "..", filepath.Dir(cwd)},
	}

	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {

	"⋄":                         "\u22c4",
	"ⅆ":                   "\u2146",
	"𝔻":                            "\U0001d53b",
	"¨":                             "\u00a8",
	"⃜":                          "\u20dc",
	"≐":                        "\u2250",
	"∯":           "\u222f",
	"¨":                       "\u00a8",

        return InetAddress.getLocalHost().getHostName();
    }

    private String removeDotSuffix(String val) {
        int dotPos = val.indexOf('.');
        return dotPos == -1 ? val : val.substring(0, dotPos);
    }


    public String getDomain() {
        return domain;
    }

    public String getUsername() {
        return username;
    }

    @Ignore
    @RunWith(CustomRunner.class)
    static class RunWithSpec {
        void doTest() {}
    }

    @Ignore
    @RunWith()
    static class EmptyRunWithSpec {
        void doTest() {}
    }

    @Ignore
    @RunWith(MissingConstructorRunner.class)
    static class MissingConstructorRunWithSpec {
        void doTest() {}
    }

    @Ignore
    static class SuiteMethodSpec {

	"path/filepath"
)

func isAbs(path string) bool {
	// on Windows, filepath.IsAbs will not return True for paths prefixed with a slash, even
	// though they can be used as absolute paths (https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats).
	return filepath.IsAbs(path) || (len(path) > 0 && (path[0] == '\\' || path[0] == '/'))

        val results = Collections.synchronizedList(mutableListOf<Boolean>())

        fun doTest() {
            reporting.enterDynamicCall(this)
            latch.countDown()
            latch.await()
            results += reporting.unreportedProblemInCurrentCall(problem)
        }

        (1..3).map { thread { doTest() } }.forEach(Thread::join)
        assertEquals(listOf(true, true, true), results)
    }

	// This mimics the configuration one much have when
	// building from distro-packaged source code
	// (see https://go.dev/issue/54852).
	parent := t.TempDir()
	dotGit := filepath.Join(parent, ".git")
	if err := os.Mkdir(dotGit, 000); err != nil {
		t.Fatal(err)
	}

	overlayStart := time.Now()

	goroot := filepath.Join(parent, "goroot")

	gorootSrc := filepath.Join(goroot, "src")