* drop escaped separators (i.e '\,').
     *
     * @param str  the <code>String</code> to unescape, may be null
     * @return the processed string
     * @throws IllegalArgumentException if the Writer is <code>null</code>
     */
    protected static String unescapeJava(String str) {
        if (str == null) {
            return null;
        }
        int sz = str.length();
        StringBuilder out = new StringBuilder(sz);

        this.zterm = zterm;
    }


    /**
     * 
     * @param str
     *            wrapped string
     * @param zterm
     *            whether the string should be zero terminated
     */
    public UnicodeString ( String str, boolean zterm ) {
        this.zterm = zterm;

        int len = str.length();
        int zt = zterm ? 1 : 0;

    await websocket.accept()
    await websocket.send_text("Hello, router!")
    await websocket.close()


@router.websocket("/router/{pathparam:path}")
async def routerindexparams(websocket: WebSocket, pathparam: str, queryparam: str):
    await websocket.accept()
    await websocket.send_text(pathparam)
    await websocket.send_text(queryparam)
    await websocket.close()


async def ws_dependency():
    return "Socket Dependency"

FastAPI 支持创建含**子依赖项**的依赖项。

并且，可以按需声明任意**深度**的子依赖项嵌套层级。

**FastAPI** 负责处理解析不同深度的子依赖项。

### 第一层依赖项

下列代码创建了第一层依赖项：

```Python hl_lines="8-9"
{!../../docs_src/dependencies/tutorial005.py!}
```

这段代码声明了类型为 `str` 的可选查询参数 `q`，然后返回这个查询参数。

这个函数很简单（不过也没什么用），但却有助于让我们专注于了解子依赖项的工作方式。

### 第二层依赖项

接下来，创建另一个依赖项函数，并同时用该依赖项自身再声明一个依赖项（所以这也是一个「依赖项」）：

```Python hl_lines="13"
{!../../docs_src/dependencies/tutorial005.py!}
```

```

////

//// tab | 🐍 3️⃣.1️⃣0️⃣ & 🔛

```Python hl_lines="6-7"
{!> ../../docs_src/dependencies/tutorial005_py310.py!}
```

////

⚫️ 📣 📦 🔢 🔢 `q` `str`, & ⤴️ ⚫️ 📨 ⚫️.

👉 🙅 (🚫 📶 ⚠), ✋️ 🔜 ℹ 👥 🎯 🔛 ❔ 🎧-🔗 👷.

## 🥈 🔗, "☑" & "⚓️"

⤴️ 👆 💪 ✍ ➕1️⃣ 🔗 🔢 ("☑") 👈 🎏 🕰 📣 🔗 🚮 👍 (⚫️ "⚓️" 💁‍♂️):

//// tab | 🐍 3️⃣.6️⃣ & 🔛

from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Product(BaseModel):
    name: str
    description: str = None  # type: ignore
    price: float


@app.get("/product")
async def create_item(product: Product):
    return product


client = TestClient(app)


def test_get_with_body():

from fastapi import FastAPI, Path, Query, status
from fastapi.testclient import TestClient

app = FastAPI()


@app.get("/{repeated_alias}")
def get_parameters_with_repeated_aliases(
    path: str = Path(..., alias="repeated_alias"),
    query: str = Query(..., alias="repeated_alias"),
):
    return {"path": path, "query": query}


client = TestClient(app)


def test_get_parameters():

@app.get("/float/{param:float}")
def float_convertor(param: float = Path()):
    return {"float": param}


@app.get("/path/{param:path}")
def path_convertor(param: str = Path()):
    return {"path": param}


@app.get("/query/")
def query_convertor(param: str = Query()):
    return {"query": param}


client = TestClient(app)


def test_route_converters_int():
    # Test integer conversion

            b[j++] = (byte)(c[i] >>> 0);
        }
        write( b, 0, blen );
    }
    public final void writeUTF( String str ) throws SmbException {
        int len = str.length();
        int ch, size = 0;
        byte[] dst;

        for( int i = 0; i < len; i++ ) {
            ch = str.charAt( i );
            size += ch > 0x07F ? (ch > 0x7FF ? 3 : 2) : 1;
        }
        dst = new byte[size];

     *
     * @see jcifs.SmbResourceLocator#getParent()
     */
    @Override
    public String getParent () {
        String str = this.url.getAuthority();

        if ( str != null && !str.isEmpty() ) {
            StringBuffer sb = new StringBuffer("smb://");

            sb.append(str);

            String urlpath = getURLPath();
            if ( urlpath.length() > 1 ) {
                sb.append(urlpath);