//	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",

		"Diamond;":                         '\U000022C4',
		"DifferentialD;":                   '\U00002146',
		"Dopf;":                            '\U0001D53B',
		"Dot;":                             '\U000000A8',
		"DotDot;":                          '\U000020DC',
		"DotEqual;":                        '\U00002250',
		"DoubleContourIntegral;":           '\U0000222F',
		"DoubleDot;":                       '\U000000A8',

go list example.com/dotgo.go
stdout ^example.com/dotgo.go$
go list example.com/dotgo.go/
stdout ^example.com/dotgo.go$

# go get should succeed in either case, with or without a version.
# Arguments are interpreted as packages or package patterns with versions,
# not source files.
go get example.com/dotgo.go
go get example.com/dotgo.go/
go get example.com/dotgo.go@v1.0.0
go get example.com/dotgo.go/@v1.0.0

        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 {

Based on github.com/nats-io/nats.go.
Used in regression tests for golang.org/issue/32483.

-- .mod --
module example.com/dotgo.go

go 1.13
-- .info --
{"Version":"v1.0.0"}
-- go.mod --
module example.com/dotgo.go

go 1.13
-- dotgo.go --