"The filename, directory name, or volume label syntax is incorrect.", "The directory is not empty.",
            "Cannot create a file when that file already exists.", "All pipe instances are busy.", "The pipe is being closed.",
            "No process is on the other end of the pipe.", "More data is available.", "This user account has expired.",

    /**
     * Get the next set of changes
     *
     * Will block until the server returns a set of changes that match the given filter. The file will be automatically
     * opened if it is not and should be closed with {@link #close()} when no longer
     * needed.
     *
     * Closing the context should cancel a pending notify request, but that does not seem to work reliable in all
     * implementations.
     *

 *
 * ```java
 * client.connectionPool().evictAll();
 * ```
 *
 * If your client has a cache, call [close()][Cache.close]. Note that it is an error to create calls
 * against a cache that is closed, and doing so will cause the call to crash.
 *
 * ```java
 * client.cache().close();
 * ```
 *
 * OkHttp also uses daemon threads for HTTP/2 connections. These will exit automatically if they
 * remain idle.

        // When
        outputStream = new SmbFileOutputStream(mockFile);

        // Then
        assertNotNull(outputStream);

        // Verify the AutoCloseable resources were closed
        verify(autoCloseableMockTreeHandle).close();
        verify(autoCloseableMockFileHandle).close();
    }

    @Test
    void testConstructorWithAppendFlag() throws IOException, CIFSException {

      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelAll() {
    val call = client.newCall(Request(server.url("/")))
    call.enqueue(callback)
    client.dispatcher.cancelAll()
    callback
      .await(server.url("/"))
      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test

import org.jspecify.annotations.Nullable;

/**
 * A readable source of bytes, such as a file. Unlike an {@link InputStream}, a {@code ByteSource}
 * is not an open, stateful stream for input that can be read and closed. Instead, it is an
 * immutable <i>supplier</i> of {@code InputStream} instances.
 *
 * <p>{@code ByteSource} provides two kinds of methods:
 *
 * <ul>

	return err.Error() == "sql: statement is closed"
}

// TestPreparedStmtConcurrentClose test calling close and executing SQL concurrently
// this test making sure that the gorm would not get a Segmentation Fault, and the only error cause by this is using a closed Stmt
func TestPreparedStmtConcurrentClose(t *testing.T) {
	name := "prepared_stmt_concurrent_close"

        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose
        writer!!.writeClose(close.code, close.reason)

        // We closed the writer: now both reader and writer are closed.
        if (sendOnClosed) {
          listener.onClosed(this, receivedCloseCode, receivedCloseReason!!)
        }
      } else {
        throw AssertionError()
      }

    public synchronized int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /* This method will not return until len bytes have been read
     * or the stream has been closed.
     */

    @Override
    public synchronized int read(final byte[] b, int off, int len) throws IOException {
        if (len == 0) {
            return 0;
        }
        int tot = 0;

     * Named pipe status indicating the connection is established and operational.
     */
    public static final int STATUS_CONNECTION_OK = 3;

    /**
     * Named pipe status indicating the server end of the pipe is closed.
     */
    public static final int STATUS_SERVER_END_CLOSED = 4;

    private int available;

    /**
     * Constructs a TransPeekNamedPipeResponse with the specified configuration.
     *