}
            return null;
        }).when(tree).send(any(Request.class));

        DirFileEntryEnumIterator2 it = new DirFileEntryEnumIterator2(tree, parent, "*", null, 0);

        // Consume the only element
        assertTrue(it.hasNext());
        assertSame(fe1, it.next());
        // After exception path, iterator should be exhausted
        assertFalse(it.hasNext());

        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("release() decrements usage; closes only when count reaches zero")
    void release_decrementsAndClosesOnZero() throws CIFSException {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(8L, true, true);

        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, () -> handle.release());
        assertTrue(ex.getMessage().contains("below zero"));
        verify(treeConnection, times(1)).release(); // still only once
    }

    @Test
    @DisplayName("acquire after release reacquires underlying tree connection")
    void acquireAfterReleaseReacquires() {

 * cases the consuming thread must call [close] when it has finished reading the response
 * body.
 *
 * ### The response body can be consumed only once.
 *
 * This class may be used to stream very large responses. For example, it is possible to use this
 * class to read a response that is larger than the entire memory allocated to the current process.

    verifyTableSize(100, 2, 4);
    verifyTableSize(100, 5, 8);
    verifyTableSize(100, 33, 64);
    verifyTableSize(60, 60, 128);
    verifyTableSize(120, 60, 256);
    // if the table is only double the necessary size, we don't bother resizing it
    verifyTableSize(180, 60, 128);
    // but if it's even bigger than double, we rebuild the table
    verifyTableSize(17, 17, 32);
    verifyTableSize(17, 16, 32);

 * }
 * }
 *
 * <p>This class cannot currently be used to test soft references, since this class does not try to
 * create the memory pressure required to cause soft references to be cleared.
 *
 * <p>This class only provides testing utilities. It is not designed for direct use in production or
 * for benchmarking.
 *
 * @author mike nonemacher
 * @author Martin Buchholz
 * @since 11.0
 */
@GwtIncompatible

  public void testAddNullEqualObject() {
    assertThrows(
        NullPointerException.class,
        () -> equalsTester.addEqualityGroup(reference, (Object[]) null));
  }

  /**
   * Test adding objects only by addEqualityGroup, with no reference object specified in the
   * constructor.
   */
  public void testAddEqualObjectWithOArgConstructor() {
    equalsTester.addEqualityGroup(equalObject1, notEqualObject1);
    try {

                    .get());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")
                    .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                    .get());
            options.addOption(Option.builder(FAIL_NEVER)
                    .longOpt("fail-never")

     * the key would be inserted into the list: the index of the next higher element in the list, or
     * {@code list.size()} if there is no such element.
     *
     * <p>Note that the return value will be {@code >= 0} if and only if there is an element of the
     * list that compares as equal to the key.
     *
     * <p>This is equivalent to the behavior of {@link java.util.Collections#binarySearch(List,

	// Max keys cannot be negative.
	if maxKeys < 0 {
		return ErrInvalidMaxKeys
	}

	if encodingType != "" {
		// AWS S3 spec only supports 'url' encoding type
		if !strings.EqualFold(encodingType, "url") {
			return ErrInvalidEncodingMethod
		}
	}

	if !IsValidObjectPrefix(prefix) {
		return ErrInvalidObjectName
	}