}

    public void setDataOffset(int dataOffset) {
        this.dataOffset = dataOffset;
    }

    public int getDataLength() {
        return dataLength;
    }

    public void setDataLength(int dataLength) {
        this.dataLength = dataLength;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(64);

        sb.append("TransferEvent[");

    }
  }

  @Test fun readPaddedDataFrame() {
    val dataLength = 1123
    val expectedData = ByteArray(dataLength)
    Arrays.fill(expectedData, 2.toByte())
    val paddingLength = 254
    val padding = ByteArray(paddingLength)
    Arrays.fill(padding, 0.toByte())
    writeMedium(frame, dataLength + paddingLength + 1)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_PADDED)

      LockFreeBitArray dataArray = new LockFreeBitArray(Math.multiplyExact(dataLength, 64L));
      for (int i = 0; i < dataLength; i++) {
        dataArray.putData(i, din.readLong());
      }

      return new BloomFilter<>(dataArray, numHashFunctions, funnel, strategy);
    } catch (IOException e) {
      throw e;
    } catch (Exception e) { // sneaky checked exception
      String message =

    peer.sendFrame().data(false, 3, Buffer().write(ByteArray(dataLength)), dataLength)
    peer.sendFrame().data(false, 3, Buffer().write(ByteArray(dataLength)), dataLength)
    peer.sendFrame().data(false, 3, Buffer().write(ByteArray(1)), 1)
    peer.sendFrame().ping(false, 2, 0) // Ping just to make sure the stream was fastforwarded.
    peer.acceptFrame() // PING
    peer.play()

    // Play it back.

    }

    val padding = if (flags and FLAG_PADDED != 0) source.readByte() and 0xff else 0
    val dataLength = lengthWithoutPadding(length, flags, padding)

    handler.data(inFinished, streamId, source, dataLength)
    source.skip(padding.toLong())
  }

  @Throws(IOException::class)
  private fun readPriority(
    handler: Handler,
    length: Int,

        bitCount.add(bitsAdded);
      }
    }

    /** Returns the number of {@code long}s in the underlying {@link AtomicLongArray}. */
    int dataLength() {
      return data.length();
    }

    @Override
    public boolean equals(@Nullable Object o) {
      if (o instanceof LockFreeBitArray) {

    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("abc")
  }

  /** Wait for the client to receive `dataLength` DATA frames.  */
  private fun waitForDataFrames(dataLength: Int) {
    val expectedFrameCount = dataLength / 16384
    var dataFrameCount = 0
    while (dataFrameCount < expectedFrameCount) {
      val log = testLogHandler.take()

		req.Body = io.NopCloser(bytes.NewReader([]byte("")))
	}

	contentLength := calculateStreamContentLength(dataLength, chunkSize)

	req.Header.Set("x-amz-content-sha256", "STREAMING-AWS4-HMAC-SHA256-PAYLOAD")
	req.Header.Set("content-encoding", "aws-chunked")
	req.Header.Set("x-amz-decoded-content-length", strconv.FormatInt(dataLength, 10))
	req.Header.Set("content-length", strconv.FormatInt(contentLength, 10))

	// Seek back to beginning.