}

func fPhi(a, b string) string {
	aslash := strings.HasSuffix(a, "/") // ERROR "Redirect Phi based on Phi$"
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

func main() {

	}
	// Same as singleJoiningSlash, but uses EscapedPath to determine
	// whether a slash should be added
	apath := a.EscapedPath()
	bpath := b.EscapedPath()

	aslash := strings.HasSuffix(apath, "/")
	bslash := strings.HasPrefix(bpath, "/")

	switch {
	case aslash && bslash:
		return a.Path + b.Path[1:], apath + bpath[1:]
	case !aslash && !bslash:
		return a.Path + "/" + b.Path, apath + "/" + bpath
	}

// See-also: https://github.com/golang/go/issues/44290
func singleJoiningSlash(a, b string) string {
	aslash := strings.HasSuffix(a, "/")
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

func (h *UpgradeAwareHandler) DialForUpgrade(req *http.Request) (net.Conn, error) {

Caio Marcelo de Oliveira Filho <******@****.***> 1514852203 -0800

					cmd = cmd[1:]
				}
				inquote = !inquote
			} else {
				b = append(b, c)
			}
			nslash = 0
			continue
		case '\\':
			nslash++
			continue
		}
		b = appendBSBytes(b, nslash)
		nslash = 0
		b = append(b, c)
	}
	return appendBSBytes(b, nslash), ""
}

// commandLineToArgv splits a command line into individual argument

// slashes are removed.
// If the path is empty, Dir returns ".".
// If the path consists entirely of slashes followed by non-slash bytes, Dir
// returns a single slash. In any other case, the returned path does not end in a
// slash.
func Dir(path string) string {
	dir, _ := Split(path)
	return Clean(dir)

			Prefix:      false,
			ExpectedMsg: "",
		},
		"dot dot,prefix": {
			Name:        "..",
			Prefix:      true,
			ExpectedMsg: "",
		},

		"slash": {
			Name:        "foo/bar",
			Prefix:      false,
			ExpectedMsg: "/",
		},
		"slash,prefix": {
			Name:        "foo/bar",
			Prefix:      true,
			ExpectedMsg: "/",
		},

		"percent": {
			Name:        "foo%bar",

			return "", errors.New("file URL encodes volume in host field: too few slashes?")
		}
		return `\\` + host + path, nil
	}

	// If host is empty, path must contain an initial slash followed by a
	// drive letter and path. Remove the slash and verify that the path is valid.
	if vol := filepath.VolumeName(path[1:]); vol == "" || strings.HasPrefix(vol, `\\`) {
		return "", errors.New("file URL missing drive letter")
	}

# .a files should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o x.a text/template
! grep 'GOROOT\\' x.a
! grep 'text\\template' x.a
! grep 'c:\\' x.a

# executables should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o hello.exe hello.go
! grep 'GOROOT\\' hello.exe

		h.WriteString(string(svc.Hostname))
		h.Write(Slash)
		h.WriteString(svc.Attributes.Namespace)
		h.Write(Separator)
	}
	h.Write(Separator)

	for _, vs := range r.VirtualServices {
		for _, cfg := range model.VirtualServiceDependencies(vs) {
			h.WriteString(cfg.Kind.String())
			h.Write(Slash)
			h.WriteString(cfg.Name)
			h.Write(Slash)
			h.WriteString(cfg.Namespace)
			h.Write(Separator)
		}