assertEquals(cap >= 0, result);
        verify(transport, times(1)).hasCapability(cap);
    }

    // Invalid input: simulate underlying SmbException when capability check fails
    @Test
    @DisplayName("hasCapability throws SmbException when underlying error occurs")
    void hasCapability_throws() throws SmbException {
        doThrow(new SmbException("capability check failed")).when(transport).hasCapability(eq(42));

    /**
     * Creates a new MimeTypeException with the specified detail message and cause.
     *
     * @param message the detail message explaining the reason for the exception
     * @param cause the underlying cause of the exception
     */
    public MimeTypeException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**

   * }
   *
   * ... prints {@code {a=[4, 16], b=[9, 9], c=[36]}}.
   *
   * <p>Changes in the underlying multimap are reflected in this view. Conversely, this view
   * supports removal operations, and these are reflected in the underlying multimap.
   *
   * <p>It's acceptable for the underlying multimap to contain null keys, and even null values

   * }
   *
   * ... prints {@code {a=[4, 16], b=[9, 9], c=[36]}}.
   *
   * <p>Changes in the underlying multimap are reflected in this view. Conversely, this view
   * supports removal operations, and these are reflected in the underlying multimap.
   *
   * <p>It's acceptable for the underlying multimap to contain null keys, and even null values

        // Assert: verify one invocation and no more
        verify(handle, times(1)).release();
        verifyNoMoreInteractions(handle);
    }

    @Test
    @DisplayName("ensureDFSResolved(): no exception when underlying call succeeds")
    void ensureDFSResolved_success() throws Exception {
        // Arrange: default mock does nothing

        // Act: call method under test
        handle.ensureDFSResolved();

        super(shortMessage);
        this.source = source;
        this.longMessage = longMessage;
    }

    /**
     * Constructs a new {@code MojoException} wrapping an underlying {@code Throwable}
     * and providing a {@code message}.
     */
    public MojoException(String message, Throwable cause) {
        super(message, cause);
    }

    /**

   * Returns a collection view of all values associated with a key. If no mappings in the multimap
   * have the provided key, an empty collection is returned.
   *
   * <p>Changes to the returned collection will update the underlying multimap, and vice versa.
   *
   * <p>Because a {@code SortedSetMultimap} has unique sorted values for a given key, this method
   * returns a {@link SortedSet}, instead of the {@link Collection} specified in the {@link

        assertSame(info, result);
        verify(tree, atLeastOnce()).send(any(CommonServerMessageBlockRequest.class), any(), any(), any());
    }

    // close() should close underlying handle with 0L when valid
    @Test
    @DisplayName("close() closes underlying handle when valid")
    void close_validHandle_invokesClose() throws Exception {
        when(handle.isValid()).thenReturn(true);

 * Supports both BoolQueryBuilder and DisMaxQueryBuilder as underlying implementations.
 */
public class DefaultQueryBuilder implements QueryBuilder {

    /** The underlying query builder being wrapped. */
    private final QueryBuilder queryBuilder;

    /** The type of the underlying query builder. */
    private final QueryType queryType;

    /**

    }

    @Test
    void getHostAddressDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostAddress()).thenReturn("192.0.2.1");
        UniAddress ua = new UniAddress(dummy);
        assertEquals("192.0.2.1", ua.getHostAddress(), "should forward hostAddress to underlying InetAddress");
    }

    @Test