diff --git a/src/developer/memory/metrics/capture.cc b/src/developer/memory/metrics/capture.cc
index d199145..cbe5749 100644
--- a/src/developer/memory/metrics/capture.cc
+++ b/src/developer/memory/metrics/capture.cc
@@ -15,114 +15,87 @@
 #include <zircon/status.h>
 
 namespace memory {
-namespace {
 
-zx_status_t get_root_resource(zx_handle_t* root_resource) {
-  const char* sysinfo = "/dev/misc/sysinfo";
-  int fd = open(sysinfo, O_RDWR);
-  if (fd < 0) {
-    FXL_LOG(ERROR) << "Cannot open sysinfo: " << strerror(errno);
-    return ZX_ERR_NOT_FOUND;
-  }
-
-  zx::channel channel;
-  zx_status_t status =
-      fdio_get_service_handle(fd, channel.reset_and_get_address());
-  if (status != ZX_OK) {
-    FXL_LOG(ERROR) << "Cannot obtain sysinfo channel: "
-                   << zx_status_get_string(status);
-    return status;
-  }
-
-  zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource(
-      channel.get(), &status, root_resource);
-  if (fidl_status != ZX_OK) {
-    FXL_LOG(ERROR) << "Cannot obtain root resource: "
-                   << zx_status_get_string(fidl_status);
-    return fidl_status;
-  } else if (status != ZX_OK) {
-    FXL_LOG(ERROR) << "Cannot obtain root resource: "
-                   << zx_status_get_string(status);
-    return status;
-  }
-  return ZX_OK;
-}
-}  // namespace
-
-class Capture::ProcessGetter final : public TaskEnumerator {
- public:
-  ProcessGetter(CaptureLevel level, zx_koid_t self_koid, Capture& capture)
-    : level_(level), self_koid_(self_koid), capture_(capture) {}
-
-  zx_status_t OnProcess(
-      int depth,
-      zx_handle_t handle,
-      zx_koid_t koid,
-      zx_koid_t parent_koid) override {
-    Process process = { .koid = koid };
-    zx_status_t s = zx_object_get_property(
-        handle, ZX_PROP_NAME, process.name, ZX_MAX_NAME_LEN);
-    if (s != ZX_OK) {
-      return s;
-    }
-    s = zx_object_get_info(handle, ZX_INFO_TASK_STATS,
-                           &process.stats, sizeof(process.stats),
-                           nullptr, nullptr);
-    if (s != ZX_OK) {
-      return s;
-    }
-
-    if (level_ == PROCESS) {
-      return ZX_OK;
-    }
-
-    if (koid == self_koid_) {
-      return ZX_OK;
-    }
-
-    size_t num_vmos;
-    s = zx_object_get_info(handle, ZX_INFO_PROCESS_VMOS,
-                           nullptr, 0, nullptr, &num_vmos);
-    if (s != ZX_OK) {
-      return s;
-    }
-    zx_info_vmo_t* vmos = new zx_info_vmo_t[num_vmos];
-    s = zx_object_get_info(handle, ZX_INFO_PROCESS_VMOS,
-                           vmos, num_vmos * sizeof(zx_info_vmo_t),
-                           &num_vmos, nullptr);
-    if (s != ZX_OK) {
-      delete[] vmos;
-      return s;
-    }
-    process.vmos.reserve(num_vmos);
-    for (size_t i = 0; i < num_vmos; i++) {
-      zx_koid_t vmo_koid = vmos[i].koid;
-      capture_.koid_to_vmo_.emplace(vmo_koid, vmos[i]);
-      process.vmos.push_back(vmo_koid);
-    }
-    delete[] vmos;
-    capture_.koid_to_process_.emplace(koid, process);
-    return ZX_OK;
-  }
-
+class OSImpl : public OS, public TaskEnumerator {
  private:
-  CaptureLevel level_;
-  zx_koid_t self_koid_;
-  Capture& capture_;
+  zx_status_t GetRootResource(zx_handle_t* root_resource) override {
+    const char* sysinfo = "/dev/misc/sysinfo";
+    int fd = open(sysinfo, O_RDWR);
+    if (fd < 0) {
+      return ZX_ERR_NOT_FOUND;
+    }
+
+    zx::channel channel;
+    zx_status_t status =
+        fdio_get_service_handle(fd, channel.reset_and_get_address());
+    if (status != ZX_OK) {
+      return status;
+    }
+
+    zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource(
+        channel.get(), &status, root_resource);
+    if (fidl_status != ZX_OK) {
+      return fidl_status;
+    }
+    return status;
+  }
+
+  zx_handle_t ProcessSelf() override { return zx_process_self(); }
+  zx_time_t GetMonotonic() override { return zx_clock_get_monotonic(); }
+
+  zx_status_t GetProcesses(
+      fit::function<zx_status_t(int, zx_handle_t, zx_koid_t, zx_koid_t)> cb)
+      override {
+    cb_ = std::move(cb);
+    return WalkRootJobTree();
+  }
+
+  zx_status_t OnProcess(int depth, zx_handle_t handle, zx_koid_t koid,
+                        zx_koid_t parent_koid) override {
+    return cb_(depth, handle, koid, parent_koid);
+  }
+
+  zx_status_t GetProperty(
+      zx_handle_t handle, uint32_t property, void* value, size_t name_len)
+     override {
+    return zx_object_get_property(handle, property, value, name_len);
+  }
+
+  zx_status_t GetInfo(
+      zx_handle_t handle,
+      uint32_t topic,
+      void* buffer,
+      size_t buffer_size,
+      size_t* actual,
+      size_t* avail) override {
+    return zx_object_get_info(
+        handle, topic, buffer, buffer_size, actual, avail);
+  }
 
   bool has_on_process() const final { return true; }
+
+  fit::function<zx_status_t(
+          int /* depth */,
+          zx_handle_t /* handle */,
+          zx_koid_t /* koid */,
+          zx_koid_t /* parent_koid */)> cb_;
 };
 
 // static.
 zx_status_t Capture::GetCaptureState(CaptureState& state) {
-  zx_status_t err = get_root_resource(&state.root);
+  OSImpl osImpl;
+  return GetCaptureState(state, osImpl);
+}
+
+zx_status_t Capture::GetCaptureState(CaptureState& state, OS& os) {
+  zx_status_t err = os.GetRootResource(&state.root);
   if (err != ZX_OK) {
     return err;
   }
 
   zx_info_handle_basic_t info;
-  err = zx_object_get_info(zx_process_self(), ZX_INFO_HANDLE_BASIC,
-                           &info, sizeof(info), nullptr, nullptr);
+  err = os.GetInfo(os.ProcessSelf(), ZX_INFO_HANDLE_BASIC,
+                   &info, sizeof(info), nullptr, nullptr);
   if (err != ZX_OK) {
     return err;
   }
@@ -132,13 +105,21 @@
 }
 
 // static.
+zx_status_t Capture::GetCapture(Capture& capture, const CaptureState& state,
+                                CaptureLevel level) {
+  OSImpl osImpl;
+  return GetCapture(capture, state, level, osImpl);
+}
+
 zx_status_t Capture::GetCapture(
-    Capture& capture, const CaptureState& state, CaptureLevel level) {
-  capture.time_ = zx_clock_get_monotonic();
-  zx_status_t err = zx_object_get_info(
-      state.root, ZX_INFO_KMEM_STATS,
-      &capture.kmem_, sizeof(capture.kmem_),
-      NULL, NULL);
+    Capture& capture,
+    const CaptureState& state,
+    CaptureLevel level,
+    OS& os) {
+  capture.time_ = os.GetMonotonic();
+  zx_status_t err = os.GetInfo(
+      state.root, ZX_INFO_KMEM_STATS, &capture.kmem_, sizeof(capture.kmem_),
+      nullptr, nullptr);
   if (err != ZX_OK) {
     return err;
   }
@@ -147,12 +128,58 @@
     return ZX_OK;
   }
 
-  ProcessGetter getter(level, state.self_koid, capture);
-  err = getter.WalkRootJobTree();
-  if (err != ZX_OK) {
-    return err;
-  }
-  return ZX_OK;
+  err = os.GetProcesses([state, &capture, level, &os](
+      int depth,
+      zx_handle_t handle,
+      zx_koid_t koid,
+      zx_koid_t parent_koid) {
+    Process process = { .koid = koid };
+    zx_status_t s = os.GetProperty(
+        handle, ZX_PROP_NAME, process.name, ZX_MAX_NAME_LEN);
+    if (s != ZX_OK) {
+      return s == ZX_ERR_BAD_STATE ? ZX_OK : s;
+    }
+    s = os.GetInfo(handle, ZX_INFO_TASK_STATS,
+                   &process.stats, sizeof(process.stats),
+                   nullptr, nullptr);
+    if (s != ZX_OK) {
+      return s == ZX_ERR_BAD_STATE ? ZX_OK : s;
+    }
+
+    if (level == PROCESS) {
+      capture.koid_to_process_.emplace(koid, process);
+      return ZX_OK;
+    }
+
+    if (koid == state.self_koid) {
+      return ZX_OK;
+    }
+
+    size_t num_vmos;
+    s = os.GetInfo(handle, ZX_INFO_PROCESS_VMOS,
+                   nullptr, 0, nullptr, &num_vmos);
+    if (s != ZX_OK) {
+      return s == ZX_ERR_BAD_STATE ? ZX_OK : s;
+    }
+    auto vmos = new zx_info_vmo_t[num_vmos];
+    s = os.GetInfo(handle, ZX_INFO_PROCESS_VMOS,
+                   vmos, num_vmos * sizeof(zx_info_vmo_t),
+                   &num_vmos, nullptr);
+    if (s != ZX_OK) {
+      delete[] vmos;
+      return s == ZX_ERR_BAD_STATE ? ZX_OK : s;
+    }
+    process.vmos.reserve(num_vmos);
+    for (size_t i = 0; i < num_vmos; i++) {
+      zx_koid_t vmo_koid = vmos[i].koid;
+      capture.koid_to_vmo_.emplace(vmo_koid, vmos[i]);
+      process.vmos.push_back(vmo_koid);
+    }
+    delete[] vmos;
+    capture.koid_to_process_.emplace(koid, process);
+    return ZX_OK;
+  });
+  return err;
 }
 
 }  // namespace memory
diff --git a/src/developer/memory/metrics/capture.h b/src/developer/memory/metrics/capture.h
index 24b890b..4bf8fa4 100644
--- a/src/developer/memory/metrics/capture.h
+++ b/src/developer/memory/metrics/capture.h
@@ -5,8 +5,9 @@
 #ifndef SRC_DEVELOPER_MEMORY_METRICS_CAPTURE_H_
 #define SRC_DEVELOPER_MEMORY_METRICS_CAPTURE_H_
 
-#include <src/lib/fxl/macros.h>
+#include <lib/fit/function.h>
 #include <lib/zx/time.h>
+#include <src/lib/fxl/macros.h>
 #include <unordered_map>
 #include <vector>
 #include <zircon/syscalls.h>
@@ -28,6 +29,28 @@
   zx_koid_t self_koid;
 };
 
+class OS {
+ public:
+  virtual zx_status_t GetRootResource(zx_handle_t* root_resource) = 0;
+  virtual zx_handle_t ProcessSelf() = 0;
+  virtual zx_time_t GetMonotonic() = 0;
+  virtual zx_status_t GetProcesses(
+      fit::function<zx_status_t(
+          int /* depth */,
+          zx_handle_t /* handle */,
+          zx_koid_t /* koid */,
+          zx_koid_t /* parent_koid */)> cb) = 0;
+  virtual zx_status_t GetProperty(
+      zx_handle_t handle, uint32_t property, void* value, size_t name_len) = 0;
+  virtual zx_status_t GetInfo(
+      zx_handle_t handle,
+      uint32_t topic,
+      void* buffer,
+      size_t buffer_size,
+      size_t* actual,
+      size_t* avail) = 0;
+};
+
 class Capture {
  public:
   static zx_status_t GetCaptureState(CaptureState& state);
@@ -55,6 +78,9 @@
   }
 
  private:
+  static zx_status_t GetCaptureState(CaptureState& state, OS& os);
+  static zx_status_t GetCapture(
+      Capture& capture, const CaptureState& state, CaptureLevel level, OS& os);
   zx_time_t time_;
   zx_info_kmem_stats_t kmem_;
   std::unordered_map<zx_koid_t, const Process> koid_to_process_;
diff --git a/src/developer/memory/metrics/tests/BUILD.gn b/src/developer/memory/metrics/tests/BUILD.gn
index 55106f2..a0a29bf3 100644
--- a/src/developer/memory/metrics/tests/BUILD.gn
+++ b/src/developer/memory/metrics/tests/BUILD.gn
@@ -14,6 +14,7 @@
   testonly = true
   output_name = "memory_metrics_unittests"
   sources = [
+    "capture_unittest.cc",
     "printer_unittest.cc",
     "summary_unittest.cc",
     "test_utils.cc",
diff --git a/src/developer/memory/metrics/tests/capture_unittest.cc b/src/developer/memory/metrics/tests/capture_unittest.cc
new file mode 100644
index 0000000..067f064
--- /dev/null
+++ b/src/developer/memory/metrics/tests/capture_unittest.cc
@@ -0,0 +1,270 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <gtest/gtest.h>
+#include <lib/gtest/test_loop_fixture.h>
+#include <zircon/types.h>
+
+#include "src/developer/memory/metrics/capture.h"
+#include "src/developer/memory/metrics/tests/test_utils.h"
+
+namespace memory {
+namespace test {
+
+using CaptureUnitTest = gtest::TestLoopFixture;
+
+const static zx_info_kmem_stats _kmem = {
+  .total_bytes = 300,
+  .free_bytes = 100,
+  .wired_bytes = 10,
+  .total_heap_bytes = 20,
+  .free_heap_bytes = 30,
+  .vmo_bytes = 40,
+  .mmu_overhead_bytes = 50,
+  .ipc_bytes = 60,
+  .other_bytes = 70
+};
+const static GetInfoResponse kmem_info = {
+  TestUtils::kRootHandle, ZX_INFO_KMEM_STATS, &_kmem, sizeof(_kmem), 1, ZX_OK
+};
+
+const static zx_info_handle_basic_t _self = {.koid = TestUtils::kSelfKoid };
+const static GetInfoResponse self_info = {
+  TestUtils::kSelfHandle, ZX_INFO_HANDLE_BASIC, &_self, sizeof(_self), 1, ZX_OK
+};
+
+const zx_koid_t proc_koid = 10;
+const zx_handle_t proc_handle = 100;
+const char proc_name[] = "P1";
+const static zx_info_task_stats _proc = {};
+const static GetInfoResponse proc_info =
+    {proc_handle, ZX_INFO_TASK_STATS, &_proc, sizeof(_proc), 1, ZX_OK};
+const static GetPropertyResponse proc_prop =
+    {proc_handle, ZX_PROP_NAME, proc_name, sizeof(proc_name), ZX_OK};
+const static GetProcessesCallback proc_cb =
+    {1, proc_handle, proc_koid, 0};
+
+const zx_koid_t proc2_koid = 20;
+const zx_handle_t proc2_handle = 200;
+const char proc2_name[] = "P2";
+const static zx_info_task_stats _proc2 = {};
+const static GetInfoResponse proc2_info =
+    {proc2_handle, ZX_INFO_TASK_STATS, &_proc2, sizeof(_proc2), 1, ZX_OK};
+const static GetPropertyResponse proc2_prop =
+    {proc2_handle, ZX_PROP_NAME, proc2_name, sizeof(proc2_name), ZX_OK};
+const static GetProcessesCallback proc2_cb =
+    {1, proc2_handle, proc2_koid, 0};
+
+const zx_koid_t vmo_koid = 1000;
+const uint64_t vmo_size = 10000;
+const char vmo_name[] = "V1";
+const static zx_info_vmo_t _vmo = {
+  .koid = vmo_koid,
+  .name = "V1",
+  .size_bytes = vmo_size,
+};
+const static GetInfoResponse vmos_info =
+    {proc_handle, ZX_INFO_PROCESS_VMOS, &_vmo, sizeof(_vmo), 1, ZX_OK};
+
+const zx_koid_t vmo2_koid = 2000;
+const uint64_t vmo2_size = 20000;
+const char vmo2_name[] = "V2";
+const static zx_info_vmo_t _vmo2 = {
+  .koid = vmo2_koid,
+  .name = "V2",
+  .size_bytes = vmo2_size,
+};
+const static GetInfoResponse vmos2_info =
+    {proc2_handle, ZX_INFO_PROCESS_VMOS, &_vmo2, sizeof(_vmo2), 1, ZX_OK};
+
+TEST_F(CaptureUnitTest, KMEM) {
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, KMEM, {
+    .get_info = {self_info, kmem_info},
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  auto const& got_kmem = c.kmem();
+  EXPECT_EQ(_kmem.total_bytes, got_kmem.total_bytes);
+}
+
+TEST_F(CaptureUnitTest, PROCESS) {
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, PROCESS, {
+    .get_info = {self_info, kmem_info, proc_info},
+    .get_processes = {{ZX_OK, {proc_cb}}},
+    .get_property = {proc_prop}
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc_koid);
+  EXPECT_EQ(proc_koid, process.koid);
+  EXPECT_STREQ(proc_name, process.name);
+}
+
+TEST_F(CaptureUnitTest, VMO) {
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, VMO, {
+    .get_info = {self_info, kmem_info, proc_info, vmos_info, vmos_info},
+    .get_processes = {{ZX_OK, {proc_cb}}},
+    .get_property = {proc_prop}
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc_koid);
+  EXPECT_EQ(proc_koid, process.koid);
+  EXPECT_STREQ(proc_name, process.name);
+  EXPECT_EQ(1U, process.vmos.size());
+  EXPECT_EQ(1U, c.koid_to_vmo().size());
+  EXPECT_EQ(vmo_koid, process.vmos[0]);
+  auto const& vmo = c.vmo_for_koid(vmo_koid);
+  EXPECT_EQ(vmo_koid, vmo.koid);
+  EXPECT_EQ(vmo_size, vmo.size_bytes);
+  EXPECT_STREQ(vmo_name, vmo.name);
+}
+
+TEST_F(CaptureUnitTest, VMODouble) {
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, VMO, {
+    .get_info = {
+      self_info,
+      kmem_info,
+      proc_info,
+      vmos_info,
+      vmos_info,
+      proc2_info,
+      vmos2_info,
+      vmos2_info,
+    },
+    .get_processes = {{ZX_OK, {proc_cb, proc2_cb}}},
+    .get_property = {proc_prop, proc2_prop}
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(2U, c.koid_to_process().size());
+  EXPECT_EQ(2U, c.koid_to_vmo().size());
+
+  auto const& process = c.process_for_koid(proc_koid);
+  EXPECT_EQ(proc_koid, process.koid);
+  EXPECT_STREQ(proc_name, process.name);
+  EXPECT_EQ(1U, process.vmos.size());
+  EXPECT_EQ(vmo_koid, process.vmos[0]);
+  auto const& vmo = c.vmo_for_koid(vmo_koid);
+  EXPECT_EQ(vmo_koid, vmo.koid);
+  EXPECT_EQ(vmo_size, vmo.size_bytes);
+  EXPECT_STREQ(vmo_name, vmo.name);
+
+  auto const& process2 = c.process_for_koid(proc2_koid);
+  EXPECT_EQ(proc2_koid, process2.koid);
+  EXPECT_STREQ(proc2_name, process2.name);
+  EXPECT_EQ(1U, process2.vmos.size());
+  EXPECT_EQ(vmo2_koid, process2.vmos[0]);
+  auto const& vmo2 = c.vmo_for_koid(vmo2_koid);
+  EXPECT_EQ(vmo2_koid, vmo2.koid);
+  EXPECT_EQ(vmo2_size, vmo2.size_bytes);
+  EXPECT_STREQ(vmo2_name, vmo2.name);
+}
+
+TEST_F(CaptureUnitTest, ProcessPropBadState) {
+  // If the process disappears we should ignore it and continue.
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, PROCESS, {
+    .get_info = {self_info, kmem_info, proc2_info},
+    .get_processes = {{ZX_OK, {proc_cb, proc2_cb}}},
+    .get_property = {
+      {proc_handle, ZX_PROP_NAME, nullptr, 0, ZX_ERR_BAD_STATE},
+      proc2_prop
+    }
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc2_koid);
+  EXPECT_EQ(proc2_koid, process.koid);
+  EXPECT_STREQ(proc2_name, process.name);
+}
+
+TEST_F(CaptureUnitTest, ProcessInfoBadState) {
+  // If the process disappears we should ignore it and continue.
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, PROCESS, {
+    .get_info = {
+      self_info,
+      kmem_info,
+      {proc_handle, ZX_INFO_TASK_STATS,
+       &_proc, sizeof(_proc), 1, ZX_ERR_BAD_STATE},
+      proc2_info
+    },
+    .get_processes = {{ZX_OK, {proc_cb, proc2_cb}}},
+    .get_property = {proc_prop, proc2_prop},
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc2_koid);
+  EXPECT_EQ(proc2_koid, process.koid);
+  EXPECT_STREQ(proc2_name, process.name);
+}
+
+TEST_F(CaptureUnitTest, VMOCountBadState) {
+  // If the process disappears we should ignore it and continue.
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, VMO, {
+    .get_info = {
+      self_info,
+      kmem_info,
+      proc_info,
+      {proc_handle, ZX_INFO_PROCESS_VMOS,
+       &_vmo, sizeof(_vmo), 1, ZX_ERR_BAD_STATE},
+      proc2_info,
+      vmos2_info,
+      vmos2_info
+    },
+    .get_processes = {{ZX_OK, {proc_cb, proc2_cb}}},
+    .get_property = {proc_prop, proc2_prop}
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc2_koid);
+  EXPECT_EQ(proc2_koid, process.koid);
+  EXPECT_STREQ(proc2_name, process.name);
+  EXPECT_EQ(1U, process.vmos.size());
+  EXPECT_EQ(1U, c.koid_to_vmo().size());
+  EXPECT_EQ(vmo2_koid, process.vmos[0]);
+  auto const& vmo = c.vmo_for_koid(vmo2_koid);
+  EXPECT_EQ(vmo2_koid, vmo.koid);
+  EXPECT_EQ(vmo2_size, vmo.size_bytes);
+  EXPECT_STREQ(vmo2_name, vmo.name);
+}
+
+TEST_F(CaptureUnitTest, VMOGetBadState) {
+  // If the process disappears we should ignore it and continue.
+  Capture c;
+  auto ret = TestUtils::GetCapture(c, VMO, {
+    .get_info = {
+      self_info,
+      kmem_info,
+      proc_info,
+      vmos_info,
+      {proc_handle, ZX_INFO_PROCESS_VMOS,
+       &_vmo, sizeof(_vmo), 1, ZX_ERR_BAD_STATE},
+      proc2_info,
+      vmos2_info,
+      vmos2_info
+    },
+    .get_processes = {{ZX_OK, {proc_cb, proc2_cb}}},
+    .get_property = {proc_prop, proc2_prop}
+  });
+  EXPECT_EQ(ZX_OK, ret);
+  EXPECT_EQ(1U, c.koid_to_process().size());
+  auto const& process = c.process_for_koid(proc2_koid);
+  EXPECT_EQ(proc2_koid, process.koid);
+  EXPECT_STREQ(proc2_name, process.name);
+  EXPECT_EQ(1U, process.vmos.size());
+  EXPECT_EQ(1U, c.koid_to_vmo().size());
+  EXPECT_EQ(vmo2_koid, process.vmos[0]);
+  auto const& vmo = c.vmo_for_koid(vmo2_koid);
+  EXPECT_EQ(vmo2_koid, vmo.koid);
+  EXPECT_EQ(vmo2_size, vmo.size_bytes);
+  EXPECT_STREQ(vmo2_name, vmo.name);
+}
+
+}  // namespace test
+}  // namespace memory
diff --git a/src/developer/memory/metrics/tests/test_utils.cc b/src/developer/memory/metrics/tests/test_utils.cc
index d614c07..dc8ba1a 100644
--- a/src/developer/memory/metrics/tests/test_utils.cc
+++ b/src/developer/memory/metrics/tests/test_utils.cc
@@ -4,8 +4,94 @@
 
 #include "src/developer/memory/metrics/tests/test_utils.h"
 
+#include <gtest/gtest.h>
+
 namespace memory {
 
+const zx_handle_t TestUtils::kRootHandle = 1;
+const zx_handle_t TestUtils::kSelfHandle = 2;
+const zx_koid_t TestUtils::kSelfKoid = 3;
+
+class MockOS : public OS {
+ public:
+  MockOS(OsResponses responses)
+      : responses_(responses),
+        i_get_processes_(0),
+        i_get_property_(0),
+        i_get_info_(0),
+        clock_(0) {}
+
+ private:
+  zx_status_t GetRootResource(zx_handle_t* root_resource) override {
+    *root_resource = TestUtils::kRootHandle;
+    return ZX_OK;
+  }
+
+  zx_handle_t ProcessSelf() override {
+    return TestUtils::kSelfHandle;
+  }
+
+  zx_time_t GetMonotonic() override {
+    return clock_++;
+  }
+
+  zx_status_t GetProcesses(
+      fit::function<zx_status_t(int, zx_handle_t, zx_koid_t, zx_koid_t)> cb)
+      override {
+    auto const& r = responses_.get_processes.at(i_get_processes_++);
+    for (auto const& c : r.callbacks) {
+      auto ret = cb(c.depth, c.handle, c.koid, c.parent_koid);
+      if (ret != ZX_OK) {
+        return ret;
+      }
+    }
+    return r.ret;
+  }
+
+  zx_status_t GetProperty(
+      zx_handle_t handle, uint32_t property, void* value, size_t name_len)
+     override {
+    auto const& r = responses_.get_property.at(i_get_property_++);
+    EXPECT_EQ(r.handle, handle);
+    EXPECT_EQ(r.property, property);
+    auto len = std::min(name_len, r.value_len);
+    memcpy(value, r.value, len);
+    return r.ret;
+  }
+
+  zx_status_t GetInfo(
+      zx_handle_t handle,
+      uint32_t topic,
+      void* buffer,
+      size_t buffer_size,
+      size_t* actual,
+      size_t* avail) override {
+    auto const& r = responses_.get_info.at(i_get_info_++);
+    EXPECT_EQ(r.handle, handle);
+    EXPECT_EQ(r.topic, topic);
+    size_t num_copied = 0;
+    if (buffer != nullptr) {
+      num_copied = std::min(r.value_count, buffer_size / r.value_size);
+      memcpy(buffer, r.values, num_copied * r.value_size);
+    }
+    if (actual != nullptr) {
+      *actual = num_copied;
+    }
+    if (avail != nullptr) {
+      if (num_copied < r.value_count) {
+        *avail = r.value_count - num_copied;
+      } else {
+        *avail = 0;
+      }
+    }
+    return r.ret;
+  }
+
+  OsResponses responses_;
+  uint32_t i_get_processes_, i_get_property_, i_get_info_;
+  zx_time_t clock_;
+};
+
 // static.
 void TestUtils::CreateCapture(memory::Capture& capture,
                               const CaptureTemplate& t) {
@@ -27,4 +113,14 @@
        [](ProcessSummary a, ProcessSummary b) { return a.koid() < b.koid(); } );
   return summaries;
 }
+
+zx_status_t TestUtils::GetCapture(
+      Capture& capture, CaptureLevel level, const OsResponses& r) {
+  MockOS os(r);
+  CaptureState state;
+  zx_status_t ret = Capture::GetCaptureState(state, os);
+  EXPECT_EQ(ZX_OK, ret);
+  return Capture::GetCapture(capture, state, level, os);
+}
+
 }  // namespace memory
diff --git a/src/developer/memory/metrics/tests/test_utils.h b/src/developer/memory/metrics/tests/test_utils.h
index f73401f..c573791 100644
--- a/src/developer/memory/metrics/tests/test_utils.h
+++ b/src/developer/memory/metrics/tests/test_utils.h
@@ -19,9 +19,50 @@
   std::vector<Process> processes;
 };
 
+struct GetProcessesCallback {
+  int depth;
+  zx_handle_t handle;
+  zx_koid_t koid;
+  zx_koid_t parent_koid;
+};
+
+struct GetProcessesResponse {
+  zx_status_t ret;
+  std::vector<GetProcessesCallback> callbacks;
+};
+
+struct GetPropertyResponse {
+  zx_handle_t handle;
+  uint32_t property;
+  const void* value;
+  size_t value_len;
+  zx_status_t ret;
+};
+
+struct GetInfoResponse {
+  zx_handle_t handle;
+  uint32_t topic;
+  const void* values;
+  size_t value_size;
+  size_t value_count;
+  zx_status_t ret;
+};
+
+struct OsResponses {
+  const std::vector<GetProcessesResponse> get_processes;
+  const std::vector<GetPropertyResponse> get_property;
+  const std::vector<GetInfoResponse> get_info;
+};
+
 class TestUtils {
  public:
+  const static zx_handle_t kRootHandle;
+  const static zx_handle_t kSelfHandle;
+  const static zx_koid_t kSelfKoid;
+
   static void CreateCapture(memory::Capture& capture, const CaptureTemplate& t);
+  static zx_status_t GetCapture(
+      Capture& capture, CaptureLevel level, const OsResponses& r);
 
   // Sorted by koid.
   static std::vector<ProcessSummary> GetProcessSummaries(