ImmutableList<String> list = ImmutableList.of("a", "b");
    assertSame(list, list.asList());
  }

  @SuppressWarnings("ModifiedButNotUsed")
  @GwtIncompatible // actually allocates nCopies
  @J2ktIncompatible // actually allocates nCopies
  public void testAddOverflowCollection() {
    ImmutableList.Builder<String> builder = ImmutableList.builder();
    for (int i = 0; i < 100; i++) {
      builder.add("a");
    }

    }

    /**
     * Helper method to create a valid security descriptor buffer with specified size
     */
    private byte[] createValidSecurityDescriptorBuffer(int size) {
        ByteBuffer buffer = ByteBuffer.allocate(size);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // Security descriptor header
        buffer.put((byte) 0x01); // Revision
        buffer.put((byte) 0x00); // Padding

     *
     * @return active connection count
     */
    public long getConnectionsActive() {
        return connectionsActive.get();
    }

    /**
     * Get total number of memory regions allocated
     *
     * @return memory region count
     */
    public long getMemoryRegionsAllocated() {
        return memoryRegionsAllocated.get();
    }

    /**

  }

  /**
   * Copies an iterable's elements into an array.
   *
   * @param iterable the iterable to copy
   * @param type the type of the elements
   * @return a newly-allocated array into which all the elements of the iterable have been copied
   */
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] toArray(

   *
   * <p><b>Note:</b> No guarantees are made regarding stability of the representation between
   * versions.
   */
  public byte[] toByteArray() {
    ByteBuffer buffer = ByteBuffer.allocate(BYTES).order(ByteOrder.LITTLE_ENDIAN);
    xStats.writeTo(buffer);
    yStats.writeTo(buffer);
    buffer.putDouble(sumOfProductsOfDeltas);
    return buffer.array();
  }

  /**

 * this class separates _allocations_ from _streams_. An allocation is created by a call, used for
 * one or more streams, and then released. An allocated connection won't be stolen by other calls
 * while a redirect or authorization challenge is being handled.
 *
 * When the maximum concurrent streams limit is reduced, some allocations will be rescinded.

            throw new SmbException("Invalid command code: " + command);
        }
    }

    /**
     * Validate array size before allocation
     *
     * @param size array size to allocate
     * @param elementSize size of each element
     * @param maxElements maximum allowed elements
     * @throws SmbException if allocation would be too large
     */

      File file = getFile();
      Reader reader = new InputStreamReader(new FileInputStream(file), UTF_8);
      StringBuilder builder = new StringBuilder();
      CharBuffer buffer = CharBuffer.allocate(100);
      while (reader.read(buffer) != -1) {
        Java8Compatibility.flip(buffer);
        builder.append(buffer);
        Java8Compatibility.clear(buffer);
      }
      return builder.toString();
    }

            cleanupExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Log final statistics
        log.info("ResourceManager shutdown complete. Total allocated: {}, released: {}, leaks: {}, force cleaned: {}", totalAllocated.get(),
                totalReleased.get(), totalLeaks.get(), cleaned);
    }

    /**
     * Create a managed resource wrapper
     *

     * copied in a single call.
     */
    @Test
    public void readBytesWireFormat_succeedsWithSingleRead() {
        DummyResponse d = new DummyResponse();
        // Allocate a transaction buffer large enough for the copy
        byte[] tx = new byte[100];
        d.txn_buf = tx;

        // Set up a scenario where the full transaction is read in one call
        d.bufParameterStart = 0;