elements[3] = e4;
    elements[4] = e5;
    elements[5] = e6;
    System.arraycopy(others, 0, elements, paramCount, others.length);
    return construct(elements.length, elements);
  }

  /**
   * Constructs an {@code ImmutableSet} from the first {@code n} elements of the specified array. If
   * {@code k} is the size of the returned {@code ImmutableSet}, then the unique elements of {@code

                    "Exception message should contain version");
            assertTrue(exception.getMessage().contains("jcifs at samba dot org"), "Exception message should contain contact info");
        }
    }

    // String Reading Tests

    @Test
    public void testOddBufferIndexAlignment() {
        // Create buffer with odd starting position

  /** Resolver for resolving covariant types with {@link #runtimeType} as context. */
  @LazyInit private transient @Nullable TypeResolver covariantTypeResolver;

  /**
   * Constructs a new type token of {@code T}.
   *
   * <p>Clients create an empty anonymous subclass. Doing so embeds the type parameter in the
   * anonymous class's type hierarchy so we can reconstitute it at runtime despite erasure.

    private NbtAddress localhostAddress;

    private final Lmhosts lmhosts = new Lmhosts();
    private Name unknownName;
    private NbtAddress unknownAddress;

    /**
     * Constructs a name service client with the given context.
     *
     * @param tc the CIFS context containing configuration
     */
    public NameServiceClientImpl(final CIFSContext tc) {

   * this fluent iterable supports it. Note that it is <i>not</i> possible to delete the last
   * skipped element by immediately calling {@code remove()} on the returned fluent iterable's
   * iterator, as the {@code Iterator} contract states that a call to {@code * remove()} before a
   * call to {@code next()} will throw an {@link IllegalStateException}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#skip} (same).
   */

   * this fluent iterable supports it. Note that it is <i>not</i> possible to delete the last
   * skipped element by immediately calling {@code remove()} on the returned fluent iterable's
   * iterator, as the {@code Iterator} contract states that a call to {@code * remove()} before a
   * call to {@code next()} will throw an {@link IllegalStateException}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#skip} (same).
   */

   * throws an {@link UnsupportedOperationException}. This also has the side effect of redefining
   * {@code equals} to comply with the Entry contract, to avoid a possible nefarious implementation
   * of equals.
   *
   * @param entry the entry for which to return an unmodifiable view
   * @return an unmodifiable view of the entry
   */

   * throws an {@link UnsupportedOperationException}. This also has the side effect of redefining
   * {@code equals} to comply with the Entry contract, to avoid a possible nefarious implementation
   * of equals.
   *
   * @param entry the entry for which to return an unmodifiable view
   * @return an unmodifiable view of the entry
   */

    private final Object dcLock = new Object();

    private CacheEntry<DfsReferralDataInternal> referrals = null;
    private final Object referralsLock = new Object();

    /**
     * Constructs a DFS resolver implementation
     *
     * @param tc the CIFS context containing configuration
     */
    public DfsImpl(final CIFSContext tc) {
    }

Il a les mêmes champs que `HeroBase`, il n'inclura donc pas `secret_name`.

Enfin, l'identité de nos héros est protégée ! 🥷

Il redéclare aussi `id: int`. Ce faisant, nous faisons un **contrat** avec les clients de l'API, afin qu'ils puissent toujours s'attendre à ce que `id` soit présent et soit un `int` (il ne sera jamais `None`).

/// tip | Astuce