Now you know that whenever you need them you can use them in **FastAPI**.

## Default values { #default-values }

You can, of course, use default values other than `None`.

Let's say that you want to declare the `q` query parameter to have a `min_length` of `3`, and to have a default value of `"fixedquery"`:

     * Stores a crawling configuration in the session-based storage with a unique identifier.
     * The generated session count ID combines the session ID with an incrementing counter.
     *
     * @param sessionId the session identifier
     * @param crawlingConfig the crawling configuration to store
     * @return the unique session count ID that can be used to retrieve the stored configuration
     */

        System.gc();
        Thread.sleep(200);

        // Check for leaks
        resourceManager.checkForLeaks();

        Map<String, Object> stats = resourceManager.getStatistics();
        // The leak counter may or may not increment depending on GC timing
        assertNotNull(stats.get("totalLeaks"));
    }

    private void createLeakyResource() {
        TestResource resource = new TestResource("leaky");

        .build(),
    )
    val asyncRequestBody: RequestBody =
      object : RequestBody() {
        var counter = 0

        override fun contentType() = null

        override fun writeTo(sink: BufferedSink) {
          counter++
          assertThat(counter).isLessThanOrEqualTo(1)
          sink.writeUtf8("Hello request!")
          sink.close()
        }

works, in source code and object code form.

b) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed
Patents to make, use, sell, offer to sell, import and otherwise transfer the
Contribution of such Contributor, if any, in source code and object code form.

    }

    /**
     * The version of this test supplied by {@link MapInterfaceTest} fails for this particular map
     * implementation, because {@code map.get()} returns a view collection that changes in the
     * course of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code
     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override

  }

  ...
}
```

We make a couple calls:

```java
Request request = new Request.Builder()
    .url("https://publicobject.com/helloworld.txt")
    .build();

System.out.println("REQUEST 1 (new connection)");
try (Response response = client.newCall(request).execute()) {
  // Consume and discard the response body.
  response.body().source().readByteString();
}

  public static void assertEqualIgnoringOrder(Iterable<?> expected, Iterable<?> actual) {
    List<?> exp = copyToList(expected);
    List<?> act = copyToList(actual);
    String actString = act.toString();

    // Of course we could take pains to give the complete description of the
    // problem on any failure.

    // Yeah it's n^2.
    for (Object object : exp) {
      if (!act.remove(object)) {
        fail(

            return context;
        }

        /**
         * Increments the counter.
         */
        public void inc() {
            counter++;
        }

        @Override
        public void close() {
            if (counter > 1) {
                counter--;
            } else {
                try {
                    if (context != null) {

context.setNumOfThread(10);       // Concurrent threads
```

### Accessing Results

```java
DataService ds = container.getComponent("dataService");

// Count
int count = ds.getCount(sessionId);

// Get by URL
AccessResult result = ds.getAccessResult(sessionId, url);

// Iterate all
ds.iterate(sessionId, accessResult -> {
    System.out.println(accessResult.getUrl());