void testMultipleCloseOnManagedResource() throws Exception {
        TestResource resource = new TestResource("multiclose");
        ResourceManager.ManagedResource<TestResource> managed = resourceManager.manage(resource);

        managed.close();
        assertTrue(resource.isClosed());

        // Second close should not throw
        assertDoesNotThrow(managed::close);
    }

    @Test

  }

  /**
   * Guaranteed to throw an exception and leave the map unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public <T extends B> @Nullable T putInstance(Class<T> type, T value) {
    throw new UnsupportedOperationException();
  }

  }

  public void testSuccessful() throws Exception {
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();
    assertThat(future.setException(cause)).isTrue();
    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {

                  throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {

     *
     * @param textual the textual representation of the SID
     * @throws SmbException if the textual format is invalid
     */
    public SID(final String textual) throws SmbException {
        final StringTokenizer st = new StringTokenizer(textual, "-");
        if (st.countTokens() < 3 || !st.nextToken().equals("S")) {
            // need S-N-M
            throw new SmbException("Bad textual SID format: " + textual);
        }

    }

    private void parse(final byte[] material) throws IOException {
        int pos = 0;
        for (int i = 0; i < 8; i++) {
            if (material[i] != NTLMSSP_SIGNATURE[i]) {
                throw new IOException("Not an NTLMSSP message.");
            }
        }
        pos += 8;

        if (readULong(material, pos) != NTLMSSP_TYPE1) {
            throw new IOException("Not a Type 1 message.");
        }

     *
     * @param url An smb URL string representing the file to write to
     * @throws SmbException if an SMB error occurs
     * @throws MalformedURLException if the URL is not properly formatted
     * @throws UnknownHostException if the host cannot be resolved
     */

    public SmbFileOutputStream(final String url) throws SmbException, MalformedURLException, UnknownHostException {
        this(url, false);
    }

   * @return all the constraints implicitly or explicitly required by the class or any of its
   *     superclasses.
   * @throws ConflictingRequirementsException if the requirements are mutually inconsistent.
   */
  public static TesterRequirements getTesterRequirements(Class<?> testerClass)
      throws ConflictingRequirementsException {
    synchronized (classTesterRequirementsCache) {

import mockwebserver3.QueueDispatcher

class QueueDispatcher : Dispatcher() {
  internal val delegate = QueueDispatcher()

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse = throw UnsupportedOperationException("unexpected call")

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {

    public void testClosedAuthenticatorBlocking() throws Exception {
        NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("DOMAIN", "user", "BlockedPass123!");

        // Close the authenticator
        auth.close();

        // All these operations should throw IllegalStateException
        assertThrows(IllegalStateException.class, () -> auth.getPassword());