if (params.containsKey("string") && params.get("string") instanceof String) {
                    return createMockRescorerBuilder();
                }
                if (params.containsKey("number") && params.get("number") instanceof Number) {
                    return createMockRescorerBuilder();
                }
                if (params.containsKey("boolean") && params.get("boolean") instanceof Boolean) {

   * </ul>
   *
   * <p>The result is guaranteed to be in the "traditional", lexicographical order for Cartesian
   * products that you would get from nesting for loops:
   *
   * {@snippet :
   * for (B b0 : lists.get(0)) {
   *   for (B b1 : lists.get(1)) {
   *     ...
   *     ImmutableList<B> tuple = ImmutableList.of(b0, b1, ...);
   *     // operate on tuple
   *   }
   * }
   * }
   *

        operationErrors.incrementAndGet();
    }
    
    public double getErrorRate() {
        long total = rdmaReads.get() + rdmaWrites.get() + rdmaSends.get() + rdmaReceives.get();
        if (total == 0) return 0.0;
        return (double) operationErrors.get() / total;
    }
    
    // Getters for all statistics...
}
```

## 9. Error Handling and Fallback

from fastapi.testclient import TestClient

app = FastAPI()

router = APIRouter()


@router.get("/users/{id}")
def read_user(segment: str, id: str):
    return {"segment": segment, "id": id}


app.include_router(router, prefix="/{segment}")


client = TestClient(app)


def test_get():
    response = client.get("/seg/users/foo")
    assert response.status_code == 200, response.text

   *   <li><i>consistency</i>: {@code comparator.compare(ti, tj) < 0} and {@code
   *       comparator.compare(tj, ti) > 0} for {@code i < j}, where {@code ti =
   *       valuesInExpectedOrder.get(i)} and {@code tj = valuesInExpectedOrder.get(j)}.
   * </ul>
   */
  public static <T extends @Nullable Object> void testComparator(
      Comparator<? super T> comparator, List<T> valuesInExpectedOrder) {

        String localRepoHead = mergedProps.get(Constants.MAVEN_REPO_LOCAL_HEAD);
        if (localRepoHead != null) {
            Arrays.stream(localRepoHead.split(","))
                    .filter(p -> p != null && !p.trim().isEmpty())
                    .map(this::resolve)
                    .forEach(paths::add);
        }
        paths.add(Paths.get(request.getLocalRepository().getBasedir()));

import inspect

from fastapi import APIRouter, FastAPI

method_names = ["get", "put", "post", "delete", "options", "head", "patch", "trace"]


def test_signatures_consistency():
    base_sig = inspect.signature(APIRouter.get)
    for method_name in method_names:
        router_method = getattr(APIRouter, method_name)
        app_method = getattr(FastAPI, method_name)
        router_sig = inspect.signature(router_method)

                    Authentication result = new Authentication(
                            authCtx.get(AuthenticationContext.USERNAME), authCtx.get(AuthenticationContext.PASSWORD));
                    result.setPrivateKey(authCtx.get(AuthenticationContext.PRIVATE_KEY_PATH));
                    result.setPassphrase(authCtx.get(AuthenticationContext.PRIVATE_KEY_PASSPHRASE));
                    authCtx.close();

        assertNotNull(result);
        assertEquals(2, result.getDocumentList().size());
        assertEquals("doc1", result.getDocumentList().get(0).get("_id"));
        assertEquals("doc2", result.getDocumentList().get(1).get("_id"));
    }

    /**
     * Test SearchResult with partial results flag.
     */
    @Test
    public void test_searchResultWithPartialResults() {

  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    long timeoutNanos = unit.toNanos(timeout);
    if (timeoutNanos <= OverflowAvoidingLockSupport.MAX_NANOSECONDS_THRESHOLD) {
      return super.get(timeout, unit);
    }
    // Waiting 68 years should be enough for any program.
    return super.get(