buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)
        buffer.putShort((short) 50); // maxMpxCount
        buffer.putShort((short) 10); // maxNumberVcs
        buffer.putInt(8192); // maxBufferSize
        buffer.putInt(65536); // maxRawSize
        buffer.putInt(123456789); // sessionKey
        buffer.putInt(SmbConstants.CAP_UNICODE | SmbConstants.CAP_NT_SMBS); // capabilities

done
DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"

# Increase the V8 stack size from the default of 984K
# to 8192K to ensure all tests can pass without hitting
# stack size limits.

   * write to {@code sink()} and close it to complete the post.
   */
  static final class PipeBody extends RequestBody {
    private final Pipe pipe = new Pipe(8192);
    private final BufferedSink sink = Okio.buffer(pipe.sink());

    public BufferedSink sink() {
      return sink;
    }

    @Override public MediaType contentType() {
      return MEDIA_TYPE_MARKDOWN;

/**
 * Transformed artifact is derived with some transformation from source artifact.
 *
 * @since TBD
 */
class TransformedArtifact extends DefaultArtifact {

    private static final int SHA1_BUFFER_SIZE = 8192;
    private final PomArtifactTransformer pomArtifactTransformer;
    private final MavenProject project;
    private final Supplier<ModelSource> sourcePathProvider;
    private final Path target;

        writeInt8(1500, buffer, 8); // caller available allocation units
        writeInt8(1500, buffer, 16); // actual free units (skipped)
        writeInt4(4, buffer, 24); // sectors per allocation unit
        writeInt4(8192, buffer, 28); // bytes per sector

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(32, bytesRead, "Should read 32 bytes");

    void getSendBufferSize_returns() throws Exception {
        // Arrange
        when(handle.getSendBufferSize()).thenReturn(8192);

        // Act
        int size = handle.getSendBufferSize();

        // Assert
        assertEquals(8192, size);
        verify(handle).getSendBufferSize();
    }

    @Test
    @DisplayName("getSendBufferSize(): propagates CIFSException on failure")

     */
    public static final int DEFAULT_SEND_CREDIT_TARGET = 32;

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**
     * Default maximum fragmented size (128KB)
     */
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072; // 128KB

    /**
     * Default maximum read/write size (1MB)
     */

      sink.write(Buffer().write(message1), message1.size.toLong())
    }
    buffer.writeByte(0x00)
    // Trailing data. We use the Okio segment size to make sure it's still in the input buffer.
    buffer.write(ByteArray(8192))
    inflater.inflate(buffer)
    assertThat(buffer.readByteString()).isEqualTo(message1)

    DeflaterSink(buffer, Deflater(Deflater.DEFAULT_COMPRESSION, true)).use { sink ->

        compressionService = new DefaultCompressionService();

        // Create test data with patterns that should compress well
        testData = generateTestData(1024);
        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {
        int[] supported = compressionService.getSupportedAlgorithms();
        assertNotNull(supported);

  }

  public void testCorrectExceptions() {
    TestHasher hasher = new TestHasher();
    assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], -1, 4));
    assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], 0, 16));
    assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], 0, -1));
  }