def test_decimal_encoder_float():
    data = {"value": Decimal(1.23)}
    assert jsonable_encoder(data) == {"value": 1.23}


def test_decimal_encoder_int():
    data = {"value": Decimal(2)}
    assert jsonable_encoder(data) == {"value": 2}


def test_decimal_encoder_nan():
    data = {"value": Decimal("NaN")}
    assert isnan(jsonable_encoder(data)["value"])

from decimal import Decimal

from dirty_equals import IsOneOf
from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, condecimal

app = FastAPI()


class Item(BaseModel):
    name: str
    age: condecimal(gt=Decimal(0.0))  # type: ignore


@app.post("/items/")
def save_item_no_body(item: list[Item]):
    return {"item": item}

    Our Id type is a prime example of this.

    >>> decimal_encoder(Decimal("1.0"))
    1.0

    >>> decimal_encoder(Decimal("1"))
    1

    >>> decimal_encoder(Decimal("NaN"))
    nan
    """
    exponent = dec_value.as_tuple().exponent
    if isinstance(exponent, int) and exponent >= 0:
        return int(dec_value)
    else:
        return float(dec_value)

        int | None,
        Doc(
            """
            Maximum number of digits allowed for decimal values.
            """
        ),
    ] = _Unset,
    decimal_places: Annotated[
        int | None,
        Doc(
            """
            Maximum number of decimal places allowed for decimal values.
            """
        ),
    ] = _Unset,
    examples: Annotated[
        list[Any] | None,

* `bytes`:
    * Standard Python `bytes`.
    * In requests and responses will be treated as `str`.
    * The generated schema will specify that it's a `str` with `binary` "format".
* `Decimal`:
    * Standard Python `Decimal`.
    * In requests and responses, handled the same as a `float`.
* You can check all the valid Pydantic data types here: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/).

        * 生成的 schema 會指定 `set` 的值為唯一（使用 JSON Schema 的 `uniqueItems`）。
* `bytes`：
    * 標準的 Python `bytes`。
    * 在請求與回應中會被當作 `str` 處理。
    * 生成的 schema 會指定其為 `str`，且 "format" 為 `binary`。
* `Decimal`：
    * 標準的 Python `Decimal`。
    * 在請求與回應中，與 `float` 的處理方式相同。
* 你可以在此查閱所有可用的 Pydantic 資料型別：[Pydantic 資料型別](https://docs.pydantic.dev/latest/usage/types/types/)。

## 範例 { #example }

以下是一個帶有參數、使用上述部分型別的 *路徑操作 (path operation)* 範例。

        * 产生的模式将指定那些 `set` 的值是唯一的 (使用 JSON Schema 的 `uniqueItems`)。
* `bytes`:
    * 标准的 Python `bytes`。
    * 在请求和响应中被当作 `str` 处理。
    * 生成的模式将指定这个 `str` 是 `binary` "格式"。
* `Decimal`:
    * 标准的 Python `Decimal`。
    * 在请求和响应中被当做 `float` 一样处理。
* 您可以在这里检查所有有效的 Pydantic 数据类型: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/)。

## 例子 { #example }

下面是一个*路径操作*的示例，其中的参数使用了上面的一些类型。

    int decimal = 0;
    int max = Integer.MAX_VALUE / 10; // for int overflow detection
    for (int i = start; i < end; i++) {
      if (decimal > max) {
        return -1;
      }
      decimal *= 10;
      int digit = Character.digit(string.charAt(i), 10);
      if (digit < 0) {
        return -1;
      }
      decimal += digit;
    }
    return decimal;
  }

        assertTrue(defaultTz.getID().length() > 0);

        // Central timezone should match default
        assertEquals(defaultTz, FessUserTimeZoneProcessProvider.centralTimeZone);
    }

    // Test with decimal values in string (should be handled by config)
    @Test
    public void test_decimalStringValues() {
        FessConfig decimalConfig = new FessConfig.SimpleImpl() {

    long rem = dividend - quotient * divisor;
    return rem - (compare(rem, divisor) >= 0 ? divisor : 0);
  }

  /**
   * Returns the unsigned {@code long} value represented by the given decimal string.
   *
   * <p><b>Java 8+ users:</b> use {@link Long#parseUnsignedLong(String)} instead.
   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code long}
   *     value