assertEquals(testString, readString);
    }

    @Test
    void testStringReadWriteUnicode() throws UnsupportedEncodingException {
        smb.useUnicode = true;
        String testString = "Hello Unicode World";
        byte[] buffer = new byte[testString.length() * 2 + 2];
        int len = smb.writeString(testString, buffer, 0);
        assertEquals(testString.length() * 2 + 2, len);

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: set[str] = set()


@app.post("/items/", response_model=Item, summary="Create an item")
async def create_item(item: Item):
    """
    Create an item with all the information:

from typing import Union

from fastapi import Body, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Item = Body(
        openapi_examples={
            "normal": {

### Créalo { #create-it }

Crea un archivo `main.py` con:

```Python
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">

        hmac.update(clientChallenge);
        hmac.digest(response, 0, 16);
        System.arraycopy(clientChallenge, 0, response, 16, 8);
        return response;
    }

    /**
     * Generate the Unicode MD4 hash for the password associated with these credentials.
     *
     * @param password the password to hash
     * @param challenge the server challenge bytes
     * @return the calculated response

from dataclasses import dataclass, field
from typing import Union

from dirty_equals import IsUUID
from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot


@dataclass
class Item:
    id: uuid.UUID
    name: str
    price: float
    tags: list[str] = field(default_factory=list)
    description: Union[str, None] = None
    tax: Union[float, None] = None


app = FastAPI()

from typing import Union

from fastapi import APIRouter, FastAPI
from pydantic import BaseModel, HttpUrl

app = FastAPI()


class Invoice(BaseModel):
    id: str
    title: Union[str, None] = None
    customer: str
    total: float


class InvoiceEvent(BaseModel):
    description: str
    paid: bool


class InvoiceEventReceived(BaseModel):
    ok: bool


invoices_callback_router = APIRouter()

    name: str
    mode: Literal["validation", "serialization"] = "validation"
    config: Union[ConfigDict, None] = None

    @property
    def alias(self) -> str:
        a = self.field_info.alias
        return a if a is not None else self.name

    @property
    def validation_alias(self) -> Union[str, None]:
        va = self.field_info.validation_alias
        if isinstance(va, str) and va:

        @DisplayName("Round-trip encoding/decoding should preserve string content")
        void testRoundTripConversion() {
            // Given
            String[] testStrings = { "Simple ASCII", "Unicode: 世界 🌍", "Mixed: ASCII + Unicode ñöt", "Special chars: !@#$%^&*()", "" };

            for (String original : testStrings) {
                // When - round trip through UNI encoding

from typing import Union


def process_item(item: Union[int, str]):