Function ASSERT_OK_AND_ASSIGN

cpp/src/arrow/memory_pool_test.cc:271–310

Read statistics into std::string

  // Read statistics into std::string
  ASSERT_OK_AND_ASSIGN(std::string stats, jemalloc_stats_string("Jax"));

  // Read statistics into std::string with a lambda
  std::string stats2;
  auto write_cb = [&stats2](const char* str) { stats2.append(str); };
  ASSERT_OK(jemalloc_stats_print(write_cb, "Jax"));

  ASSERT_EQ(stats.rfind("{\"jemalloc\":{\"version\"", 0), 0);
  ASSERT_EQ(stats2.rfind("{\"jemalloc\":{\"version\"", 0), 0);
  ASSERT_EQ(stats.substr(0, 100), stats2.substr(0, 100));
#else
  std::string stats;
  auto write_cb = [&stats](const char* str) { stats.append(str); };
  ASSERT_RAISES(NotImplemented, jemalloc_get_stat("thread.peak.read"));
  ASSERT_RAISES(NotImplemented, jemalloc_get_stat("stats.allocated"));
  ASSERT_RAISES(NotImplemented, jemalloc_get_stat("stats.allocated"));
  ASSERT_RAISES(NotImplemented, jemalloc_get_stat("stats.allocatedp"));
  ASSERT_RAISES(NotImplemented, jemalloc_peak_reset());
  ASSERT_RAISES(NotImplemented, jemalloc_stats_print(write_cb, "Jax"));
  ASSERT_RAISES(NotImplemented, jemalloc_stats_print("ax"));
#endif
}

class TestCappedMemoryPool : public ::arrow::TestMemoryPoolBase {
 public:
  MemoryPool* memory_pool() override { return InitPool(/*limit=*/1'000'000'000LL); }

  MemoryPool* InitPool(int64_t limit) {
    proxy_memory_pool_ = std::make_shared<ProxyMemoryPool>(default_memory_pool());
    capped_memory_pool_ =
        std::make_shared<CappedMemoryPool>(proxy_memory_pool_.get(), limit);
    return capped_memory_pool_.get();
  }

 protected:
  std::shared_ptr<MemoryPool> proxy_memory_pool_;
  std::shared_ptr<CappedMemoryPool> capped_memory_pool_;
};

TEST_F(TestCappedMemoryPool, MemoryTracking) { this->TestMemoryTracking(); }

TEST_F(TestCappedMemoryPool, OOM) {
  // CappedMemoryPool rejects the huge allocation without hitting the underlying