Function AssertChunkingBlockSize

cpp/src/arrow/json/chunker_test.cc:121–152

}

void AssertChunkingBlockSize(Chunker& chunker, std::shared_ptr<Buffer> buf,
                             int64_t block_size, int expected_count) {
  std::shared_ptr<Buffer> partial = Buffer::FromString({});
  int64_t pos = 0;
  int total_count = 0;
  while (pos < buf->size()) {
    int count;
    auto block = SliceBuffer(buf, pos, std::min(block_size, buf->size() - pos));
    pos += block->size();
    std::shared_ptr<Buffer> completion, whole, next_partial;

    if (pos == buf->size()) {
      // Last block
      ASSERT_OK(chunker.ProcessFinal(partial, block, &completion, &whole));
    } else {
      std::shared_ptr<Buffer> starts_with_whole;
      ASSERT_OK(
          chunker.ProcessWithPartial(partial, block, &completion, &starts_with_whole));
      ASSERT_OK(chunker.Process(starts_with_whole, &whole, &next_partial));
    }
    // partial + completion should be a valid JSON block
    ASSERT_OK_AND_ASSIGN(partial, ConcatenateBuffers({partial, completion}));
    AssertOnlyWholeObjects(chunker, partial, &count);
    total_count += count;
    // whole should be a valid JSON block
    AssertOnlyWholeObjects(chunker, whole, &count);
    total_count += count;
    partial = next_partial;
  }
  ASSERT_EQ(pos, buf->size());
  ASSERT_EQ(total_count, expected_count);
}

void AssertStraddledChunking(Chunker& chunker, const std::shared_ptr<Buffer>& buf) {
  auto first_half = SliceBuffer(buf, 0, buf->size() / 2);