* callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the
 * appropriate {@code copyOf} method itself.
 *
 * <p>Expressing the immutability guarantee directly in the type that user code references is a
 * powerful advantage. Although Java offers certain immutable collection factory methods, such as
 * {@link Collections#singleton(Object)} and <a

 * <i>similar</i>.
 *
 * <h3>Nullability</h3>
 *
 * <p>A converter always converts {@code null} to {@code null} and non-null references to non-null
 * references. It would not make sense to consider {@code null} and a non-null reference to be
 * "different representations of the same information", since one is distinguishable from

  }

  /**
   * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code
   * backingMap}. The caller surrenders control of the backing map, and thus should not allow any
   * direct references to it to remain accessible.
   */
  public static <B extends @Nullable Object> MutableClassToInstanceMap<B> create(
      Map<Class<? extends @NonNull B>, B> backingMap) {
    return new MutableClassToInstanceMap<>(backingMap);

   * about arrays for now, as they're a mess.
   */
  public static <T extends @Nullable Object> T[] newArray(T[] reference, int length) {
    T[] empty = reference.length == 0 ? reference : Arrays.copyOf(reference, 0);
    return Arrays.copyOf(empty, length);
  }

  /**
   * Returns a new array that contains the concatenated contents of two arrays.
   *

        assertEquals(2048, negotiationWithLargeBuffers.getResponseRaw().length);
    }

    @Test
    @DisplayName("Fields should be immutable after construction")
    void testImmutability() {
        // Get references to the objects
        SmbNegotiationRequest originalRequest = negotiation.getRequest();
        SmbNegotiationResponse originalResponse = negotiation.getResponse();

            ExceptionSummary summary, Map<String, String> references, String indent, boolean showErrors) {
        String referenceKey = "";

        if (summary.getReference() != null && !summary.getReference().isEmpty()) {
            referenceKey =
                    references.computeIfAbsent(summary.getReference(), k -> "[Help " + (references.size() + 1) + "]");
        }

   * <i>happen-before</i></a> its execution begins, perhaps in another thread.
   *
   * <p>Guava implementations of {@code ListenableFuture} promptly release references to listeners
   * after executing them.
   *
   * @param listener the listener to run when the computation is complete
   * @param executor the executor to run the listener in

      return created;
    }

    // N.B. Draining the queue is only necessary to ensure that we don't accumulate empty references
    // in the array. We could skip this if we decide we don't care about holding on to Reference
    // objects indefinitely.
    private void drainQueue() {
      Reference<? extends L> ref;
      while ((ref = queue.poll()) != null) {

             * as task inputs and therefore Gradle attempts to snapshot them before/after task execution. This fails due
             * to the GStrings containing references to non-serializable objects.
             *
             * We bypass this by instead passing this system properties vi a CommandLineArgumentProvider. This has the added

     * @throws CIFSException if the type cannot be determined
     */
    int getType() throws CIFSException;

    /**
     * Determines whether this resource represents a workgroup reference.
     *
     * @return whether this is a workgroup reference
     * @throws CIFSException if the determination cannot be made
     */
    boolean isWorkgroup() throws CIFSException;

    /**