Dans la plupart des cas, vous avez (et devez avoir) un « termination proxy » au‑dessus qui gère le HTTPS pour vous ; cela dépend de la façon dont vous déployez votre application : votre fournisseur peut le faire pour vous, ou vous devrez le configurer vous‑même.

/// tip | Astuce

     */
    private static List<Path> paths() {
        return List.of(Path.of("src", "foo.java"), Path.of("src", "bar.java"));
    }

    /**
     * Converts paths from Unix style to platform-dependent style.
     *
     * @param expected the option value expected by the test
     * @return the expected value with separators of the host
     */
    private static String toPlatformSpecific(String expected) {

   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Equivalence} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Equivalence} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override

        assertEquals(d1, d2);

        // Different type -> false
        assertFalse(a.equals("not-an-auth"));
    }

    @Test
    @DisplayName("isAnonymous: depends on subject presence and super")
    void isAnonymous_behaviour() {
        Kerb5Authenticator anon = new Kerb5Authenticator((Subject) null);

In most cases you would (and should) have a "termination proxy" handling HTTPS for you on top, this will depend on how you deploy your application, your provider might do this for you, or you might need to set it up yourself.

/// tip

You can learn more about it in the [deployment documentation](deployment/index.md).

 * invoke methods, they invoke methods on the {@code ForwardingList}.
 *
 * <p>The {@code standard} methods and any collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingList<E extends @Nullable Object> extends ForwardingCollection<E>

 * invoke methods, they invoke methods on the {@code ForwardingSortedMultiset}.
 *
 * <p>The {@code standard} methods and any collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 * @since 15.0
 */
@GwtCompatible
public abstract class ForwardingSortedMultiset<E extends @Nullable Object>

- **core-runtime**: Provides the runtimes or "containers" in which code runs. These runtimes include the Gradle client, the daemon and the worker processes. This is the base module on which all other architecture modules depend.
- **core-configuration**: Allows the build structure and work, such as tasks, to be specified. This includes the project model, the DSL and so on.

 * supported. The elements can be any objects.
 *
 * <p>{@code contains(x)}, {@code add(x)} and {@code remove(x)}, are all (expected and amortized)
 * constant time operations. Expected in the hashtable sense (depends on the hash function doing a
 * good job of distributing the elements to the buckets to a distribution not far from uniform), and
 * amortized since some operations can trigger a hash table resize.
 *

        // Escaped asterisks should not be converted to italics
        assertFalse(result.contains(""));
    }

    @Test
    public void test_render_strikethrough() {
        // Note: This depends on whether the extension is enabled
        String result = markdownRenderer.render("~~strikethrough~~");
        // Just verify it doesn't break
        assertNotNull(result);
    }

    @Test