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);

        mockPipeResource = mock(SmbPipeResource.class);
        mockSmbPipeHandleInternal = mock(SmbPipeHandleInternal.class);
        mockInputStream = mock(InputStream.class);
        mockOutputStream = mock(OutputStream.class);

        // Create a mock implementation of the SmbPipeHandle interface
        smbPipeHandle = mock(SmbPipeHandle.class);

        // Define behavior for the mock handle

    delegate!!.sslParameters = p
  }

  @Throws(IOException::class)
  override fun close() {
    delegate!!.close()
  }

  override fun getInetAddress(): InetAddress = delegate!!.inetAddress

  @Throws(IOException::class)
  override fun getInputStream(): InputStream = delegate!!.inputStream

  @Throws(SocketException::class)
  override fun getKeepAlive(): Boolean = delegate!!.keepAlive

     * </p>
     *
     * @param bytes the byte array (must not be {@literal null})
     * @param filter the ObjectInputFilter to use, or null to disable filtering
     * @return the deserialized object
     * @throws IORuntimeException if an I/O error occurs or if a class is rejected by the filter
     * @throws ClassNotFoundRuntimeException if the class of a serialized object cannot be found

     */
    public static Boolean toBoolean(final Object o) {
        return switch (o) {
        case null -> null;
        case Boolean b -> b;
        case Number n -> n.intValue() != 0;
        case String s -> switch (s.toLowerCase()) {
        case "true" -> Boolean.TRUE;
        case "false", "0" -> Boolean.FALSE;
        default -> Boolean.TRUE;
        };
        default -> Boolean.TRUE;
        };

 *   <li>{@code close()} - Closes the stream and deletes the temporary file if it is not needed.</li>
 * </ul>
 */
public class ContentOutputStream extends DeferredFileOutputStream {

    /**
     * The logger for this class.
     */
    protected static final Logger logger = Logger.getLogger(ContentOutputStream.class.getName());

    /**
     * The prefix for the temporary file name.

Any function that is valid to use with:

* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> or
* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" class="external-link" target="_blank">`@contextlib.asynccontextmanager`</a>

would be valid to use as a **FastAPI** dependency.

        }

        @Test
        @DisplayName("close() closes handle; does not close file when not unshared")
        void closeClosesHandle() throws Exception {
            SmbFileInputStream in = newStream();
            in.close();
            verify(mockHandle, times(1)).close();
            verify(mockFile, never()).close();
        }

        @Test

            break;
        case CHECK_LAST_MODIFIED:
            processCheckLastModified(objs);
            break;
        case NOT_MODIFIED:
            processNotModified(objs);
            break;
        case GET_CONTENT:
            processGetContent(objs);
            break;
        case REDIRECT_LOCATION:
            processRedirectLocation(objs);
            break;
        case PROCESS_RESPONSE:

    }
    handler.windowUpdate(streamId, increment)
  }

  @Throws(IOException::class)
  override fun close() {
    source.close()
  }

  /**
   * Decompression of the header block occurs above the framing layer. This class lazily reads
   * continuation frames as they are needed by [Hpack.Reader.readHeaders].
   */
  internal class ContinuationSource(
    private val source: BufferedSource,
  ) : Source {