/** The default value of the initial capacity */
    public static final int INITIAL_CAPACITY = 17;

    /** The default value of the load factor */
    public static final float LOAD_FACTOR = 0.75f;

    /** Load factor */
    protected transient int threshold;

    /** Entry as a map */
    protected transient Entry<K, V>[] mapTable;

    /** Entry as an array */

    }

    @Test
    void testPopulateWithInclude() throws Exception {
        // Test that include directives are processed (even if the include fails)
        // The main file content should still be loaded

        // Create a temporary lmhosts file with include directive
        File lmhostsFile = tempDir.resolve("lmhosts_include").toFile();

        try (FileWriter writer = new FileWriter(lmhostsFile)) {

To summarize for any encrypted object there exists (at least) three different keys:

- [OEK](#oek): A secret and unique key used to encrypted the object, stored in an encrypted form as part of the object metadata and only loaded to RAM in plaintext during en/decrypting the object.

                    builder.setCredentials(credentials);
                } catch (final IOException e) {
                    throw new StorageException("Failed to load GCS credentials from " + credentialsPath, e);
                }
            }
            // If no credentials path, uses default credentials (GOOGLE_APPLICATION_CREDENTIALS env var)
        }

 * from uniform), and amortized since some operations can trigger a hash table resize.
 *
 * <p>As compared with {@link java.util.LinkedHashMap}, this structure places significantly reduced
 * load on the garbage collector by only using a constant number of internal objects.
 *
 * <p>This class should not be assumed to be universally superior to {@code

 * from its source file.
 */
public class SynonymFile extends DictionaryFile<SynonymItem> {
    private static final String SYNONYM = "synonym";

    /** The list of synonym items loaded from the dictionary file. */
    List<SynonymItem> synonymItemList;

    /**
     * Constructs a new synonym file.
     *
     * @param id        The unique identifier for this dictionary file.

				// skipped, like the meta-bucket.
				if isReservedOrInvalidBucket(volInfo.Name, false) {
					continue
				}

				healBuckets.Compute(volInfo.Name, func(oldValue VolInfo, loaded bool) (newValue VolInfo, del bool) {
					if loaded {
						newValue = oldValue
						newValue.count = oldValue.count + 1
						return newValue, false
					}
					return VolInfo{
						Name:    volInfo.Name,

        assertEquals("replacement", result);
    }

    @Test
    public void test_load_withoutPathMappingBhv() {
        final PathMappingHelper helper = new PathMappingHelper();
        int result = helper.load();
        assertEquals(0, result);
    }

    @Test
    public void test_init_called() {
        final PathMappingHelper helper = new PathMappingHelper();
        helper.init();

        return Holder.INSTANCE;
    }

    /** Holder class for lazy initialization of the default instance */
    private static final class Holder {
        static final XmlService INSTANCE = ServiceLoader.load(XmlService.class)
                .findFirst()
                .orElseThrow(() -> new IllegalStateException("No XmlService implementation found"));

        private Holder() {}
    }

│   └── main.py
├── Dockerfile
└── requirements.txt
```

#### Derrière un proxy de terminaison TLS { #behind-a-tls-termination-proxy }

Si vous exécutez votre conteneur derrière un proxy de terminaison TLS (load balancer) comme Nginx ou Traefik, ajoutez l'option `--proxy-headers`, cela indiquera à Uvicorn (via la CLI FastAPI) de faire confiance aux en-têtes envoyés par ce proxy lui indiquant que l'application s'exécute derrière HTTPS, etc.