server.listener.assertExhausted()
    server.source.close()
    client.source.close()
    taskFaker.runTasks()
    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test
  fun close() {
    client.webSocket!!.close(1000, "Hello!")
    // This will trigger a close response.
    assertThat(server.processNextFrame()).isFalse()

            lenient().doNothing().when((DcerpcHandle) handle).close();

            // Setup close to call real method which will then call our mocked components
            doCallRealMethod().when(handle).close();

            handle.close();

            verify(mockSmbPipeHandleInternal).close();
            verify(mockSmbNamedPipe).close();
        }

        @Test

                mockSession.close();
            }, "Multiple close() calls should not throw exceptions");

            verify(mockSession, times(2)).close();
        }

        @Test
        @DisplayName("Should handle close with exception gracefully")
        void shouldHandleCloseExceptionGracefully() throws Exception {
            SmbSession mockSession = mock(SmbSession.class);

  private var receivedCloseCode = -1

  /** The close reason from the peer, or null if this web socket has not yet read a close frame. */
  private var receivedCloseReason: String? = null

  /** True if this web socket failed and the listener has been notified. */
  private var failed = false

  /** Total number of pings sent by this web socket. */

            executor.shutdown();
        }
    }

    /**
     * Test close() method
     */
    @Test
    void testClose() throws CIFSException {
        // Execute
        watchHandle.close();

        // Verify close was called
        verify(watchHandle, times(1)).close();
    }

    /**
     * Test close() method throwing CIFSException
     */
    @Test

        TestIterator iterator = new TestIterator(null);
        iterator.close();

        verify(delegate).close();
    }

    @Test
    @DisplayName("Close propagates exception")
    void closeException() throws CIFSException {
        when(delegate.hasNext()).thenReturn(false);
        doThrow(new CIFSException("Close failed")).when(delegate).close();

        TestIterator iterator = new TestIterator(null);

   * any exceptions thrown when attempting to close a closeable will be suppressed. Otherwise, the
   * <i>first</i> exception to be thrown from an attempt to close a closeable will be thrown and any
   * additional exceptions that are thrown after that will be suppressed.
   */
  @Override
  public void close() throws IOException {
    Throwable throwable = thrown;

    // close closeables in LIFO order
    while (!stack.isEmpty()) {

    }

    // 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);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        sut.close();

        verify(handle, times(1)).close(0L);

 * * `Response.body().close()`
 * * `Response.body().source().close()`
 * * `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`

        InOrder inOrder = inOrder(handle, fd, tree);
        inOrder.verify(handle, times(1)).ensureOpen();
        inOrder.verify(fd, times(1)).getTree();
        inOrder.verify(tree, times(1)).send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY));
        verify(fd, times(1)).close();
        verify(tree, times(1)).close();
    }

    @ParameterizedTest