cos.write(2);
        cos.write(3);
        assertTrue(cos.isInMemory());
        cos.write(4); // Exceeds threshold
        assertFalse(cos.isInMemory());
        File file = cos.getFile();
        assertTrue(file.exists());
        cos.close();
    }

    @Test
    public void testGetDataInMemory() throws IOException {
        // getData() should return the written data when in memory

        assertEquals(0x00, trans.maxSetupCount);
        assertEquals(2, trans.setupCount);
        assertEquals("\\PIPE\\", trans.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct data")
    void testWriteSetupWireFormat() {
        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);

        body.writeTo(sink)
      }

      sink.write(CRLF)
    }

    sink!!.write(DASHDASH)
    sink.write(boundaryByteString)
    sink.write(DASHDASH)
    sink.write(CRLF)

    if (countBytes) {
      byteCount += byteCountBuffer!!.size
      byteCountBuffer.clear()
    }

    return byteCount
  }

  class Part private constructor(

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten, "Should write 4 bytes");
        // Check that structure size (4) is written as 2-byte little-endian
        assertEquals(4, buffer[offset] | (buffer[offset + 1] << 8), "Structure size should be 4");
        assertEquals(0, buffer[offset + 2], "Reserved bytes should be 0");

        // Then
        assertNotNull(transCallNamedPipe);
        assertEquals(TEST_PIPE_NAME, transCallNamedPipe.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct bytes")
    void testWriteSetupWireFormat() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, TEST_DATA.length);
        byte[] dst = new byte[10];

			// we have written the entire stream, return right here.
			return written, nil
		}

		if eof {
			// We reached EOF prematurely but we did not write everything
			// that we promised that we would write.
			if totalSize > 0 && written != totalSize {
				return written, io.ErrUnexpectedEOF
			}
			return written, nil
		}
	}
}

// SafeClose safely closes any channel of any type

import okio.Buffer
import okio.BufferedSink

/** Writes HTTP/2 transport frames. */
@Suppress("NAME_SHADOWING")
class Http2Writer(
  private val sink: BufferedSink,
  private val client: Boolean,
) : Closeable,
  Lockable {
  private val hpackBuffer: Buffer = Buffer()
  private var maxFrameSize: Int = INITIAL_MAX_FRAME_SIZE
  private var closed: Boolean = false
  val hpackWriter: Hpack.Writer = Hpack.Writer(out = hpackBuffer)

    // drop the contract on the method that enforces this queue like behavior since depending on it
    // is likely to be a bug anyway.

    // N.B. All writes to the list and the next pointers must have happened before the above
    // synchronized block, so we can iterate the list without the lock held here.
    RunnableExecutorPair reversedList = null;
    while (list != null) {

            bufferIndex += bc;
        }
        return bufferIndex - start;
    }

    /**
     * Writes the SMB2 header to the wire format.
     *
     * @param dst the destination buffer
     * @param dstIndex the starting position in the buffer
     * @return number of bytes written
     */
    protected int writeHeaderWireFormat(final byte[] dst, final int dstIndex) {

        }

        // Test zero time separately - it's handled specially
        SMBUtil.writeTime(0L, buffer, 0);
        long readTime = SMBUtil.readTime(buffer, 0);
        // When writing 0, it writes 0 directly, and when reading 0, it returns negative offset
        assertEquals(-SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601, readTime);
    }

    @Test
    void testUTimeConversionRoundTrip() {