assertThrows(IllegalArgumentException.class, () -> multiset.add(KEY, COUNT_TO_ADD));
  }

  /**
   * Simulate some of the races that can happen on add. We can't easily simulate the race that
   * happens when an {@link AtomicInteger#compareAndSet} fails, but we can simulate the case where
   * the putIfAbsent returns a non-null value, and the case where the replace() of an observed zero
   * fails.
   */

from fastapi import Depends, FastAPI

app = FastAPI()


@dataclass
class DatabasePaginator:
    offset: int = 0
    limit: int = 100
    q: str | None = None

    def get_page(self) -> dict:
        # Simulate a page of data
        return {
            "offset": self.offset,
            "limit": self.limit,
            "q": self.q,
            "items": [],
        }


def get_db_paginator(

        // Create a hook that simulates an exception scenario
        AtomicBoolean exceptionHandled = new AtomicBoolean(false);

        FessCurtainFinallyHook customHook = new FessCurtainFinallyHook() {
            @Override
            public void hook(final FwAssistantDirector assistantDirector) {
                try {
                    // Simulate a scenario where the method exists but invocation fails

    }

    // Test handling of processing exception
    @Test
    public void test_execute_withProcessingException() {
        // Create a mock that returns 0 to simulate processing error
        SearchEngineClient errorClient = new SearchEngineClient() {
            @Override
            public long updateByQuery(String index,

Then you can use this new class in `response_class=PNGStreamingResponse` in your *path operation function*:

{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}

### Simulate a File { #simulate-a-file }

In this example, we are simulating a file with `io.BytesIO`, which is a file-like object that lives only in memory, but lets us use the same interface.

    Returns `True` if the cancellation was delivered (i.e. it did not hang).
    """
    chunks: list[bytes] = []

    async def receive():  # type: ignore[no-untyped-def]
        # Simulate a client that never disconnects, rely on cancellation
        await anyio.sleep(float("inf"))
        return {"type": "http.disconnect"}  # pragma: no cover

    async def send(message: dict) -> None:  # type: ignore[type-arg]

        }
        long setDuration = System.nanoTime() - setStartTime;

        // For comparison, simulate array-based lookup
        long arrayStartTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            // Simulate original array-based lookup
            boolean found = false;
            for (String field : queryFieldConfig.sortFields) {

        assertEquals(3, passedRetries.get());
    }

    /**
     * Creates a testable CoordinatorHelper that overrides tryStartOperation(name,data,retries)
     * to simulate "create always fails" (no OpenSearch), preserving the retry/cleanup dispatch logic.
     */
    private CoordinatorHelper createRetryTestHelper(final AtomicBoolean cleanupCalled, final AtomicInteger cleanupRetries,

        // Second immediate call should use cache
        names = testFactory.getDataStoreNames();
        assertEquals(2, names.length);
        assertEquals(1, loadCount[0]); // Should not increment

        // Simulate time passing (more than 60 seconds)
        testFactory.lastLoadedTime = System.currentTimeMillis() - 61000L;

        // Should reload after cache expiry
        names = testFactory.getDataStoreNames();

        Exception exception = new Exception() {
            @Override
            public void printStackTrace(java.io.PrintWriter writer) {
                // Simulate a normal stack trace output
                writer.println("Special test exception");
                writer.flush();
            }
        };

        monitorTarget.appendException(buf, exception);