}
		return info, nil
	} // In all other cases cache the value upto 1sec.

	client.diskInfoCache.InitOnce(time.Second, cachevalue.Opts{},
		func(ctx context.Context) (info DiskInfo, err error) {
			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
			defer cancel()

			nopts := DiskInfoOptions{DiskID: *client.diskID.Load(), Metrics: true}

 *
 * <p><b>Warning:</b> {@code ArrayTable} is rarely the {@link Table} implementation you want. First,
 * it requires that the complete universe of rows and columns be specified at construction time.
 * Second, it is always backed by an array large enough to hold a value for every possible
 * combination of row and column keys. (This is rarely optimal unless the table is extremely dense.)

    @Override
    public void clear() {
      backingMap.clear();
    }
  }

  /**
   * {@inheritDoc}
   *
   * <p>The set's iterator traverses the mappings for the first row, the mappings for the second
   * row, and so on.
   *
   * <p>Each cell is an immutable snapshot of a row key / column key / value mapping, taken at the
   * time the cell is returned by a method call to the set or its iterator.
   */

        // First call should create a new Handler
        URLStreamHandler handler1 = cifsContextWrapper.getUrlHandler();
        assertNotNull(handler1);
        assertTrue(handler1 instanceof Handler);

        // Second call should return the same instance
        URLStreamHandler handler2 = cifsContextWrapper.getUrlHandler();
        assertEquals(handler1, handler2);
    }

    @Test
    void testGetSIDResolver() {

        assertTrue(authorizations.contains(mockAuthData1), "The list should contain the first mocked auth data.");
        assertTrue(authorizations.contains(mockAuthData2), "The list should contain the second mocked auth data.");
    }

```
.
├── backend
│   ├── main.py
│   ├── __init__.py
```

Vous définiriez alors le `entrypoint` comme suit :

```toml
[tool.fastapi]
entrypoint = "backend.main:app"
```

ce qui serait équivalent à :

```python
from backend.main import app
```

### `fastapi dev` avec un chemin { #fastapi-dev-with-path }

		},
		{
			reqURL:    "http://127.0.0.1:8443/?DurationSeconds=800",
			expectErr: true,
		},
		{
			reqURL:   "http://127.0.0.1:8443/?DurationSeconds=901",
			duration: time.Duration(901) * time.Second,
		},
	}

	for i, testCase := range testCases {
		u, err := url.Parse(testCase.reqURL)
		if err != nil {
			t.Fatal(err)
		}
		d, err := GetDefaultExpiration(u.Query().Get("DurationSeconds"))

		},
	})

	for i := 0; i < int(limit); i++ {
		if err := batch.Add(testItem); err != nil {
			t.Fatalf("failed to add %v; %v", i, err)
		}
	}

	batch.Close()
	time.Sleep(1 * time.Second)

	batchLen := batch.Len()
	if batchLen != 0 {
		t.Fatalf("Expected batch.Len()=0; but got %v", batchLen)
	}

	keys := store.List()
	if len(keys) != 1 {

        String response2 = checkGetMethod(searchBody, "").asString();
        Integer status2 = JsonPath.from(response2).get("response.status");
        assertEquals(Integer.valueOf(0), status2, "Second call should return status 0");

        String response3 = checkGetMethod(searchBody, "").asString();
        Integer status3 = JsonPath.from(response3).get("response.status");

/**
 * Checks adoc files for reversed multi-language snippet order.
 * Only rule enforced:
 *   In a ==== ... ==== block, if there are at least two [.multi-language-sample] snippets,
 *   flag when the first is GROOVY and the second is KOTLIN.
 */
@CacheableTask
public abstract class FindBadMultiLangSnippets extends DefaultTask {

    @InputDirectory
    @PathSensitive(PathSensitivity.RELATIVE)