* * `Response.body().charStream().close()`
 * * `Response.body().byteStream().close()`
 * * `Response.body().bytes()`
 * * `Response.body().string()`
 *
 * There is no benefit to invoking multiple `close()` methods for the same response body.
 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`

        verify(tree).connectLogon(ctx);
    }

    @Test
    @DisplayName("Should sort addresses by fail count and failover")
    void testFailoverWithFailCounts() throws Exception {
        // Given: Multiple addresses with different fail counts
        Address addr1 = mock(Address.class);
        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);

      private val useCompression: Boolean = true,
      private val out: Buffer,
    ) {
      /**
       * In the scenario where the dynamic table size changes multiple times between transmission of
       * header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE

            }
        }

        /*
         * NOTE: This is primarily to keep backward-compat with Maven 2.x which did not validate that dependencies are
         * unique within a single POM. Upon multiple declarations, 2.x just kept the last one but retained the order of
         * the first occurrence. So when we're in lenient/compat mode, we have to deal with such broken POMs and mimic

            if (context.options().goals().isEmpty()
                    || context.options().goals().get().size() != 1) {
                return badGoalsErrorMessage("No goal or multiple goals specified, specify only one goal.", context);
            }

            String goalName = context.options().goals().get().get(0);
            Goal goal = context.goals.get(goalName);

    /**
     * Executes and optionally caches a batch of requests using the provided supplier function.
     * This method allows for efficient batch processing of multiple requests.
     * <p>
     * The implementation may optimize the execution by:
     * <ul>
     *   <li>Returning cached results for previously executed requests</li>

  {{.HelpName}} {{if .VisibleFlags}}[FLAGS] {{end}}DIR{1...64}
  {{.HelpName}} {{if .VisibleFlags}}[FLAGS] {{end}}DIR{1...64} DIR{65...128}

DIR:
  DIR points to a directory on a filesystem. When you want to combine
  multiple drives into a single large system, pass one directory per
  filesystem separated by space. You may also use a '...' convention
  to abbreviate the directory arguments. Remote directories in a

            bb.get(encodedPath);
            assertArrayEquals(pathBytes, encodedPath);
        }

        @Test
        @DisplayName("Should encode consistently on multiple calls")
        void testEncodeIdempotency() {
            String path = "\\\\server\\share";
            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst1 = new byte[buffer.size()];

        assertSame(testException, thrownException, "Should propagate exception from delegate");
        verify(mockDelegate).getResponseTimeout();
    }

    @Test
    @DisplayName("Multiple method calls should result in multiple delegate calls")
    void testMultipleDelegateCalls() {
        // Given
        when(mockDelegate.getResponseTimeout()).thenReturn(30000);

        // When

   *
   * <p>This is guaranteed to return zero if the dataset contains only exactly one finite value. It
   * is not guaranteed to return zero when the dataset consists of the same value multiple times,
   * due to numerical errors. However, it is guaranteed never to return a negative result.
   *
   * <h3>Non-finite values</h3>
   *