*/
    protected abstract FileEntry[] getResults();

    /**
     * Closes the enumeration and releases resources.
     *
     * @throws CIFSException if an error occurs during closing
     */
    protected synchronized void doClose() throws CIFSException {
        // otherwise already closed
        if (!this.closed) {
            this.closed = true;
            try {
                doCloseInternal();

        assertFalse(auth.isClosed());

        // Close the authenticator
        auth.close();

        // Verify it's closed
        assertTrue(auth.isClosed());
        // Cannot check password after closing as it now throws IllegalStateException
        // This is actually good security practice - closed authenticators cannot be accessed

        // Verify multiple closes don't cause issues

        h.close(777L);

        // Verify SMB2 close path
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));
        // Tree is always released in finally
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close(long) sends SMB1 close request and releases tree when SMB1")

   ([#123190](https://github.com/kubernetes/kubernetes/pull/123190), [@padlar](https://github.com/padlar))
- Allowed scheduling framework plugins that implement `io.Closer` to be gracefully closed.
   ([#122498](https://github.com/kubernetes/kubernetes/pull/122498), [@Gekko0114](https://github.com/Gekko0114))
- Bumped cAdvisor to `v0.49.0`.

    }

    @Test
    @DisplayName("Test initial state is CLOSED")
    void testInitialState() {
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());
        assertTrue(circuitBreaker.allowsRequests());
    }

    @Test
    @DisplayName("Test successful calls in CLOSED state")
    void testSuccessfulCalls() throws Exception {

        return fileInputStream.available();
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     * @throws IOException if an I/O error occurs.
     */
    @Override
    public void close() throws IOException {
        try {
            fileInputStream.close();
        } finally {
            FileUtil.deleteInBackground(tempFile);
        }
    }

        measureTime {
          val exception =
            assertFailsWith<IOException> {
              response.trailers()
            }
          assertThat(exception.message).isIn(
            "Socket closed", // HTTP/1.1
            "stream was reset: CANCEL", // HTTP/2
          )
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
      assertThat(trailersDelay).isLessThan(750.milliseconds)

    client.listener.assertFailure(IOException::class.java, "canceled")
    taskFaker.runTasks()
  }

  @Test
  fun serverCloseClosesConnection() {
    server.webSocket!!.close(1000, "Hello!")
    client.processNextFrame() // Read server close, send client close, close connection.
    assertThat(client.closed).isFalse()
    client.listener.assertClosing(1000, "Hello!")

    }
  }

  /**
   * Closes this connection. This cancels all open streams and unanswered pings. It closes the
   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,

        // Need successThreshold (2) consecutive successes to close the circuit
        // Second success should close the circuit (threshold is 2)
        result = circuitBreaker.executeWithCircuitBreaker(() -> "success 1");
        assertEquals("success 1", result, "Should execute second success");
        assertEquals(State.CLOSED, circuitBreaker.getState(), "Circuit should be CLOSED after success threshold");