var trailers: Headers? = null

    var closed: Boolean = false

    @Throws(IOException::class)
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      assertLockNotHeld()

      sendBuffer.write(source, byteCount)
      while (sendBuffer.size >= EMIT_BUFFER_SIZE) {
        emitFrame(false)
      }
    }

    /**

            ByteArrayOutputStream baos = new ByteArrayOutputStream(length);
            byte[] buffer = new byte[1024];

            while (!deflater.finished()) {
                int compressedSize = deflater.deflate(buffer);
                baos.write(buffer, 0, compressedSize);
            }

            deflater.end();
            return baos.toByteArray();
        } catch (Exception e) {

import jcifs.smb1.Config;
import jcifs.smb1.util.LogStream;

/**
Do not use this class. Writing to the OutputStream of this type of socket
requires leaving a 4 byte prefix for the NBT header. IOW you must call
write( buf, 4, len ). Calling write( buf, 0, len ) will generate an error.
 */

public class NbtSocket extends Socket {

    private static final int SSN_SRVC_PORT = 139;
    private static final int BUFFER_SIZE = 512;

     * other SMB clients will be permitted to read from the target file while
     * this file is open. This constant may be logically OR'd with other share
     * access flags.
     */
    int FILE_SHARE_READ = 0x01;
    /**
     * When specified as the <code>shareAccess</code> constructor parameter,
     * other SMB clients will be permitted to write to the target file while

        }

        @Override
        public void write(final byte[] b) throws IOException {
            this.stream.write(b);
            this.collector.write(b);
        }

        @Override
        public void write(final byte[] b, final int off, final int len) throws IOException {
            this.stream.write(b, off, len);
            this.collector.write(b, off, len);
        }

        @Override

  issue_comment:
    types:
      - created
  issues:
    types:
      - labeled
  pull_request_target:
    types:
      - labeled
  workflow_dispatch:

permissions:
  issues: write
  pull-requests: write

jobs:
  issue-manager:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
    steps:
      - name: Dump GitHub context
        env:

    Reader reader = source.openStream();

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertExpectedString(writer.toString());
  }

  public void testOpenBufferedStream() throws IOException {

func NewLRWMutex() *LRWMutex {
	return &LRWMutex{}
}

// Lock holds a write lock on lm.
//
// If the lock is already in use, the calling go routine
// blocks until the mutex is available.
func (lm *LRWMutex) Lock() {
	const isWriteLock = true
	lm.lockLoop(context.Background(), lm.id, lm.source, math.MaxInt64, isWriteLock)
}

// GetLock tries to get a write lock on lm before the timeout occurs.

                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;
                }
                j = i;
                while (j < data.length && !Character.isWhitespace(data[j])) {
                    j++;
                }

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

        while (true) {
            while (bip > 0) {
                n = in.read(b, off, Math.min(len, bip));
                if (n == -1) {
                    return tot > 0 ? tot : -1;
                }
                tot += n;