// Edge-like Windows UNC-style: a single backslash in the path
        String reqPath = "\\";
        String resolved = "smb://server/share/path";
        when(locator.handleDFSReferral(referral, reqPath)).thenReturn(resolved);

        String out = locator.handleDFSReferral(referral, reqPath);
        assertEquals(resolved, out);

        // Verify exact argument interaction

            when(mockReferral.getNode()).thenReturn("\\server\\share\\path");

            String reqPath = "\\\\server\\share\\path";
            // Use valid consumed value within string bounds (reqPath.length() = 19)
            int consumed = Math.min(19, reqPath.length());

            data1 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);

                log.debug("Server " + dr.server + " path " + reqPath + " remain " + reqPath.substring(consumed) + " path consumed "
                        + consumed);
            }
            dr.pathConsumed = consumed;
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Node " + ref.getNode() + " path " + reqPath + " remain " + reqPath.substring(consumed) + " path consumed "

    /**
     * Internal: for testing only
     *
     * @param dr the DFS referral data to process
     * @param reqPath the requested path to resolve
     * @return resolved unc path
     */
    String handleDFSReferral(DfsReferralData dr, String reqPath);

		RXTotalDuration: delta,
		Error:           errStr,
		TotalConn:       uint64(connectionsPerPeer),
	}
}

// perfNetRequest - reader for http.request.body
func perfNetRequest(ctx context.Context, deploymentID, reqPath string, reader io.Reader) (result madmin.SiteNetPerfNodeResult) {
	result = madmin.SiteNetPerfNodeResult{}
	cli, err := globalSiteReplicationSys.getAdminClient(ctx, deploymentID)
	if err != nil {
		result.Error = err.Error()

    }

    /**
     * @param dr
     * @param reqPath
     * @return UNC path the redirect leads to
     */
    @Override
    public String handleDFSReferral(final DfsReferralData dr, final String reqPath) {
        if (Objects.equals(this.dfsReferral, dr)) {
            return this.unc;
        }
        this.dfsReferral = dr;

	entry := NewEntry(deploymentID)

	entry.RemoteHost = handlers.GetSourceIP(r)
	entry.UserAgent = r.UserAgent()
	entry.ReqClaims = reqClaims
	entry.ReqHost = r.Host
	entry.ReqPath = r.URL.Path

	q := r.URL.Query()
	reqQuery := make(map[string]string, len(q))
	for k, v := range q {
		reqQuery[k] = strings.Join(v, ",")
	}
	entry.ReqQuery = reqQuery

    res: list[str] = []
    lang_docs_root = Path("docs") / lang / "docs"
    for path in iter_all_lang_paths(lang_docs_root):
        relpath = path.relative_to(lang_docs_root)
        if not str(relpath).startswith(non_translated_sections):
            res.append(str(relpath))
    return res


def process_one_page(path: Path) -> bool:
    """
    Fix one translated document by comparing it to the English version.

        @Override
        public String getLocation() {
            return source.getLocation();
        }

        @Override
        public ModelSource2 getRelatedSource(String relPath) {
            Source rel = source.resolve(relPath);
            return rel != null ? new SourceWrapper(rel) : null;
        }

        @Override
        public URI getLocationURI() {
            Path path = source.getPath();

        yield path


def iter_en_paths_to_translate() -> Iterable[Path]:
    en_docs_root = Path("docs/en/docs/")
    for path in iter_all_en_paths():
        relpath = path.relative_to(en_docs_root)
        if not str(relpath).startswith(non_translated_sections):
            yield path


@app.command()
def translate_lang(language: Annotated[str, typer.Option(envvar="LANGUAGE")]) -> None: