diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 6c438e8..91b80d9 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -252,7 +252,6 @@
 }
 
 // Scans flash memory within a sector to find a KVS entry magic.
-// TODO(frolv): This needs to be unit tested!
 Status KeyValueStore::ScanForEntry(const SectorDescriptor& sector,
                                    Address start_address,
                                    Address* next_entry_address) {
@@ -803,7 +802,6 @@
   sector->RemoveWritableBytes(result.size());
 
   if (!result.ok()) {
-    // TODO: Once fake flash errors are supported in tests, test this branch.
     ERR("Failed to write %zu bytes at %" PRIx32 ". %zu actually written",
         entry.size(),
         address,
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 136e548..e914c39 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -240,24 +240,6 @@
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
 };
 
-uint16_t CalcKvsCrc(const char* key, const void* data, size_t data_len) {
-  uint16_t crc = checksum::CcittCrc16(as_bytes(span(key, std::strlen(key))));
-  return checksum::CcittCrc16(span(static_cast<const byte*>(data), data_len),
-                              crc);
-}
-
-uint16_t CalcTestPartitionCrc() {
-  byte buf[16];  // Read as 16 byte chunks
-  EXPECT_EQ(sizeof(buf) % test_partition.alignment_bytes(), 0u);
-  EXPECT_EQ(test_partition.size_bytes() % sizeof(buf), 0u);
-  uint16_t crc = checksum::kCcittCrc16DefaultInitialValue;
-  for (size_t i = 0; i < test_partition.size_bytes(); i += sizeof(buf)) {
-    test_partition.Read(i, buf);
-    crc = checksum::CcittCrc16(as_bytes(span(buf)), crc);
-  }
-  return crc;
-}
-
 }  // namespace
 
 TEST_F(EmptyInitializedKvs, Put_SameKeySameValueRepeatedly_AlignedEntries) {
@@ -578,11 +560,11 @@
 
     // Write the same entry many times.
     const char* key = "abcd";
-    const size_t num_writes = 1;  // TODO: Make this > 1 when things work.
+    const size_t num_writes = 99;
     uint32_t written_value;
     EXPECT_EQ(kvs.size(), (reload == 0) ? 0 : 1u);
     for (uint32_t i = 0; i < num_writes; ++i) {
-      INF("PUT #%zu for key %s with value %zu", size_t(i), key, size_t(i));
+      DBG("PUT #%zu for key %s with value %zu", size_t(i), key, size_t(i));
 
       written_value = i + 0xfc;  // Prevent accidental pass with zero.
       EXPECT_OK(kvs.Put(key, written_value));
@@ -590,13 +572,11 @@
     }
 
     // Verify that we can read the value back.
-    INF("GET final value for key: %s", key);
+    DBG("GET final value for key: %s", key);
     uint32_t actual_value;
     EXPECT_OK(kvs.Get(key, &actual_value));
     EXPECT_EQ(actual_value, written_value);
 
-    kvs.LogDebugInfo();
-
     char fname_buf[64] = {'\0'};
     snprintf(&fname_buf[0],
              sizeof(fname_buf),
@@ -623,13 +603,12 @@
   for (size_t i = 0; i < num_writes; ++i) {
     StringBuffer<150> key;
     key << "key_" << i;
-    INF("PUT #%zu for key %s with value %zu", i, key.c_str(), i);
+    DBG("PUT #%zu for key %s with value %zu", i, key.c_str(), i);
 
     size_t value = i + 77;  // Prevent accidental pass with zero.
     EXPECT_OK(kvs.Put(key.view(), value));
     EXPECT_EQ(kvs.size(), i + 1);
   }
-  kvs.LogDebugInfo();
   flash.Dump("WritingMultipleKeysIncreasesSize.bin");
 }
 
@@ -646,12 +625,12 @@
 
   // Add two entries with different keys and values.
   const char* key = "Key1";
-  INF("PUT value for key: %s", key);
+  DBG("PUT value for key: %s", key);
   uint8_t written_value = 0xDA;
   ASSERT_OK(kvs.Put(key, written_value));
   EXPECT_EQ(kvs.size(), 1u);
 
-  INF("GET value for key: %s", key);
+  DBG("GET value for key: %s", key);
   uint8_t actual_value;
   ASSERT_OK(kvs.Get(key, &actual_value));
   EXPECT_EQ(actual_value, written_value);
@@ -674,23 +653,18 @@
   ASSERT_OK(kvs.Init());
 
   // Add two entries with different keys and values.
-  INF("PUT first value");
   uint8_t value1 = 0xDA;
   ASSERT_OK(kvs.Put(key1, as_bytes(span(&value1, sizeof(value1)))));
   EXPECT_EQ(kvs.size(), 1u);
 
-  INF("PUT second value");
   uint32_t value2 = 0xBAD0301f;
   ASSERT_OK(kvs.Put(key2, value2));
   EXPECT_EQ(kvs.size(), 2u);
 
-  INF("--------------------------------");
-  INF("GET second value");
   // Verify data
   uint32_t test2;
   EXPECT_OK(kvs.Get(key2, &test2));
 
-  INF("GET first value");
   uint8_t test1;
   ASSERT_OK(kvs.Get(key1, &test1));
 
@@ -937,14 +911,12 @@
   }
 }
 
-#if 0  // Offset reads are not yet supported
-
 TEST_F(EmptyInitializedKvs, OffsetRead) {
   const char* key = "the_key";
   constexpr size_t kReadSize = 16;  // needs to be a multiple of alignment
   constexpr size_t kTestBufferSize = kReadSize * 10;
   ASSERT_GT(buffer.size(), kTestBufferSize);
-  ASSERT_LE(kTestBufferSize, 0xFF);
+  ASSERT_LE(kTestBufferSize, 0xFFu);
 
   // Write the entire buffer
   for (size_t i = 0; i < kTestBufferSize; i++) {
@@ -956,15 +928,23 @@
   // Read in small chunks and verify
   for (unsigned i = 0; i < kTestBufferSize / kReadSize; i++) {
     std::memset(buffer.data(), 0, buffer.size());
-    ASSERT_EQ(
-        Status::OK,
-        kvs_.Get(key, span(buffer.data(), kReadSize), i * kReadSize).status());
+    StatusWithSize result =
+        kvs_.Get(key, span(buffer.data(), kReadSize), i * kReadSize);
+
+    ASSERT_EQ(kReadSize, result.size());
+
+    // Only last iteration is OK since all remaining data was read.
+    if (i == kTestBufferSize / kReadSize - 1) {
+      ASSERT_EQ(Status::OK, result.status());
+    } else {  // RESOURCE_EXHAUSTED, since there is still data to read.
+      ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+    }
+
     for (unsigned j = 0; j < kReadSize; j++) {
       ASSERT_EQ(static_cast<unsigned>(buffer[j]), j + i * kReadSize);
     }
   }
 }
-#endif
 
 TEST_F(EmptyInitializedKvs, MultipleRewrite) {
   // Calculate number of elements to ensure multiple sectors are required.
@@ -1200,377 +1180,17 @@
 
 #endif  // USE_MEMORY_BUFFER
 
-TEST_F(EmptyInitializedKvs, DifferentValueSameCrc16) {
-  const char kKey[] = "k";
-  // With the key and our CRC16 algorithm these both have CRC of 0x82AE
-  // Given they are the same size and same key, the KVS will need to check
-  // the actual bits to know they are different.
-  const char kValue1[] = {'d', 'a', 't'};
-  const char kValue2[] = {'u', 'c', 'd'};
-
-  // Verify the CRC matches
-  ASSERT_EQ(CalcKvsCrc(kKey, kValue1, sizeof(kValue1)),
-            CalcKvsCrc(kKey, kValue2, sizeof(kValue2)));
-
-  ASSERT_EQ(Status::OK, kvs_.Put(kKey, kValue1));
-
-  // Now try to rewrite with the similar value.
-  ASSERT_EQ(Status::OK, kvs_.Put(kKey, kValue2));
-
-  // Read it back and check it is correct
-  char value[3] = {};
-  ASSERT_EQ(Status::OK, kvs_.Get(kKey, &value));
-  ASSERT_EQ(std::memcmp(value, kValue2, sizeof(value)), 0);
-}
-
-TEST_F(EmptyInitializedKvs, CallingEraseTwice) {
+TEST_F(EmptyInitializedKvs, CallingEraseTwice_NothingWrittenToFlash) {
   const uint8_t kValue = 0xDA;
   ASSERT_EQ(Status::OK, kvs_.Put(keys[0], kValue));
   ASSERT_EQ(Status::OK, kvs_.Delete(keys[0]));
-  uint16_t crc = CalcTestPartitionCrc();
+
+  // Compare before / after checksums to verify that nothing was written.
+  const uint16_t crc = checksum::CcittCrc16(test_flash.buffer());
+
   EXPECT_EQ(kvs_.Delete(keys[0]), Status::NOT_FOUND);
-  // Verify the flash has not changed
-  EXPECT_EQ(crc, CalcTestPartitionCrc());
-}
 
-#if 0  // TODO: not CanFitEntry function yet
-TEST_F(EmptyInitializedKvs, DISABLED_CanFitEntryTests) {
-  // Get exactly the number of bytes that can fit in the space remaining for
-  // a large value, accounting for alignment.
-  constexpr uint16_t kTestKeySize = 2;
-  size_t space_remaining =
-      test_partition.sector_size_bytes()          //
-      - RoundUpForAlignment(sizeof(EntryHeader))  // TODO: Sector Header
-      - RoundUpForAlignment(sizeof(EntryHeader))  // Cleaning Header
-      - RoundUpForAlignment(sizeof(EntryHeader))  // TODO: Chunk Header
-      - RoundUpForAlignment(kTestKeySize);
-  space_remaining -= test_partition.alignment_bytes() / 2;
-  space_remaining = RoundUpForAlignment(space_remaining);
-
-  EXPECT_TRUE(kvs_.CanFitEntry(kTestKeySize, space_remaining));
-  EXPECT_FALSE(kvs_.CanFitEntry(kTestKeySize, space_remaining + 1));
-}
-#endif
-
-void __attribute__((noinline)) StackHeavyPartialClean() {
-#if 0  // TODO: No FlashSubPartition
-
-  ASSERT_GE(test_partition.sector_count(), 2);
-  FlashSubPartition test_partition_sector1(&test_partition, 0, 1);
-  FlashSubPartition test_partition_sector2(&test_partition, 1, 1);
-
-  KeyValueStore kvs1(&test_partition_sector1);
-  KeyValueStore kvs2(&test_partition_sector2);
-
-  test_partition.Erase(0, test_partition.sector_count());
-
-  ASSERT_EQ(Status::OK, kvs1.Enable());
-  ASSERT_EQ(Status::OK, kvs2.Enable());
-
-  int values1[3] = {100, 101, 102};
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
-
-  int values2[3] = {200, 201, 202};
-  ASSERT_EQ(Status::OK, kvs2.Put(keys[0], values2[0]));
-  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values2[1]));
-  ASSERT_EQ(Status::OK, kvs2.Delete(keys[1]));
-
-  kvs1.Disable();
-  kvs2.Disable();
-
-  // Key 0 is value1 in first sector, value 2 in second
-  // Key 1 is value1 in first sector, erased in second
-  // key 2 is only in first sector
-
-  uint64_t mark_clean_count = 5;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector1,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-
-  // Reset KVS
-  kvs_.Disable();
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  int value;
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values2[0], value);
-  ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NOT_FOUND);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values1[2], value);
-
-  if (test_partition.sector_count() == 2) {
-    EXPECT_EQ(kvs_.PendingCleanCount(), 0u);
-    // Has forced a clean, mark again for next test
-    return;  // Not enough sectors to test 2 partial cleans.
-  } else {
-    EXPECT_EQ(kvs_.PendingCleanCount(), 1u);
-  }
-
-  mark_clean_count--;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector2,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-  // Reset KVS
-  kvs_.Disable();
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  EXPECT_EQ(kvs_.PendingCleanCount(), 2u);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values1[0], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[1], &value));
-  ASSERT_EQ(values1[1], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values1[2], value);
-#endif
-}
-
-// TODO: This doesn't do anything, and would be unreliable anyway.
-size_t CurrentTaskStackFree() { return -1; }
-
-TEST_F(EmptyInitializedKvs, DISABLED_PartialClean) {
-  if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 2) {
-    PW_LOG_ERROR("Not enough stack for test, skipping");
-    return;
-  }
-  StackHeavyPartialClean();
-}
-
-void __attribute__((noinline)) StackHeavyCleanAll() {
-#if 0  // TODO: no FlashSubPartition
-  ASSERT_GE(test_partition.sector_count(), 2);
-  FlashSubPartition test_partition_sector1(&test_partition, 0, 1);
-
-  KeyValueStore kvs1(&test_partition_sector1);
-  test_partition.Erase(0, test_partition.sector_count());
-
-  ASSERT_EQ(Status::OK, kvs1.Enable());
-
-  int values1[3] = {100, 101, 102};
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
-  ASSERT_EQ(Status::OK,
-            kvs1.Put(keys[2], values1[2] - 100));  //  force a rewrite
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
-
-  kvs1.Disable();
-
-  uint64_t mark_clean_count = 5;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector1,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-
-  // Reset KVS
-  kvs_.Disable();
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  int value;
-  EXPECT_EQ(kvs_.PendingCleanCount(), 1u);
-  ASSERT_EQ(Status::OK, kvs_.CleanAll());
-  EXPECT_EQ(kvs_.PendingCleanCount(), 0u);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values1[0], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[1], &value));
-  ASSERT_EQ(values1[1], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values1[2], value);
-#endif
-}
-
-TEST_F(EmptyInitializedKvs, DISABLED_CleanAll) {
-  if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 1) {
-    PW_LOG_ERROR("Not enough stack for test, skipping");
-    return;
-  }
-  StackHeavyCleanAll();
-}
-
-void __attribute__((noinline)) StackHeavyPartialCleanLargeCounts() {
-#if 0
-  ASSERT_GE(test_partition.sector_count(), 2);
-  FlashSubPartition test_partition_sector1(&test_partition, 0, 1);
-  FlashSubPartition test_partition_sector2(&test_partition, 1, 1);
-
-  KeyValueStore kvs1(&test_partition_sector1);
-  KeyValueStore kvs2(&test_partition_sector2);
-
-  test_partition.Erase(0, test_partition.sector_count());
-
-  ASSERT_EQ(Status::OK, kvs1.Enable());
-  ASSERT_EQ(Status::OK, kvs2.Enable());
-
-  int values1[3] = {100, 101, 102};
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values1[0]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values1[1]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values1[2]));
-
-  int values2[3] = {200, 201, 202};
-  ASSERT_EQ(Status::OK, kvs2.Put(keys[0], values2[0]));
-  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values2[1]));
-  ASSERT_EQ(Status::OK, kvs2.Delete(keys[1]));
-
-  kvs1.Disable();
-  kvs2.Disable();
-  kvs_.Disable();
-
-  // Key 0 is value1 in first sector, value 2 in second
-  // Key 1 is value1 in first sector, erased in second
-  // key 2 is only in first sector
-
-  uint64_t mark_clean_count = 4569877515;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector1,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-
-  // Reset KVS
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  int value;
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values2[0], value);
-  ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NOT_FOUND);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values1[2], value);
-
-  if (test_partition.sector_count() == 2) {
-    EXPECT_EQ(kvs_.PendingCleanCount(), 0u);
-    // Has forced a clean, mark again for next test
-    // Has forced a clean, mark again for next test
-    return;  // Not enough sectors to test 2 partial cleans.
-  } else {
-    EXPECT_EQ(kvs_.PendingCleanCount(), 1u);
-  }
-  kvs_.Disable();
-
-  mark_clean_count--;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector2,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-  // Reset KVS
-  ASSERT_EQ(Status::OK, kvs_.Init());
-  EXPECT_EQ(kvs_.PendingCleanCount(), 2u);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values1[0], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[1], &value));
-  ASSERT_EQ(values1[1], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values1[2], value);
-#endif
-}
-
-TEST_F(EmptyInitializedKvs, DISABLED_PartialCleanLargeCounts) {
-  if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 2) {
-    PW_LOG_ERROR("Not enough stack for test, skipping");
-    return;
-  }
-  StackHeavyPartialCleanLargeCounts();
-}
-
-void __attribute__((noinline)) StackHeavyRecoverNoFreeSectors() {
-#if 0  // TODO: no FlashSubPartition
-  ASSERT_GE(test_partition.sector_count(), 2);
-  FlashSubPartition test_partition_sector1(&test_partition, 0, 1);
-  FlashSubPartition test_partition_sector2(&test_partition, 1, 1);
-  FlashSubPartition test_partition_both(&test_partition, 0, 2);
-
-  KeyValueStore kvs1(&test_partition_sector1);
-  KeyValueStore kvs2(&test_partition_sector2);
-  KeyValueStore kvs_both(&test_partition_both);
-
-  test_partition.Erase(0, test_partition.sector_count());
-
-  ASSERT_EQ(Status::OK, kvs1.Enable());
-  ASSERT_EQ(Status::OK, kvs2.Enable());
-
-  int values[3] = {100, 101};
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values[0]));
-  ASSERT_FALSE(kvs1.HasEmptySector());
-  ASSERT_EQ(Status::OK, kvs2.Put(keys[1], values[1]));
-  ASSERT_FALSE(kvs2.HasEmptySector());
-
-  kvs1.Disable();
-  kvs2.Disable();
-
-  // Reset KVS
-  ASSERT_EQ(Status::OK, kvs_both.Enable());
-  ASSERT_TRUE(kvs_both.HasEmptySector());
-  int value;
-  ASSERT_EQ(Status::OK, kvs_both.Get(keys[0], &value));
-  ASSERT_EQ(values[0], value);
-  ASSERT_EQ(Status::OK, kvs_both.Get(keys[1], &value));
-  ASSERT_EQ(values[1], value);
-#endif
-}
-
-TEST_F(EmptyInitializedKvs, RecoverNoFreeSectors) {
-  if (CurrentTaskStackFree() < sizeof(KeyValueStore) * 3) {
-    PW_LOG_ERROR("Not enough stack for test, skipping");
-    return;
-  }
-  StackHeavyRecoverNoFreeSectors();
-}
-
-void __attribute__((noinline)) StackHeavyCleanOneSector() {
-#if 0  // TODO: no FlashSubPartition
-  ASSERT_GE(test_partition.sector_count(), 2);
-  FlashSubPartition test_partition_sector1(&test_partition, 0, 1);
-  FlashSubPartition test_partition_sector2(&test_partition, 1, 1);
-
-  KeyValueStore kvs1(&test_partition_sector1);
-
-  test_partition.Erase(0, test_partition.sector_count());
-
-  ASSERT_EQ(Status::OK, kvs1.Enable());
-
-  int values[3] = {100, 101, 102};
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[0], values[0]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[1], values[1]));
-  ASSERT_EQ(Status::OK, kvs1.Put(keys[2], values[2]));
-
-  kvs1.Disable();
-  kvs_.Disable();
-
-  uint64_t mark_clean_count = 1;
-  ASSERT_EQ(Status::OK,
-            PaddedWrite(&test_partition_sector1,
-                        RoundUpForAlignment(KeyValueStore::kHeaderSize),
-                        reinterpret_cast<uint8_t*>(&mark_clean_count),
-                        sizeof(uint64_t)));
-
-  // Reset KVS
-  ASSERT_EQ(Status::OK, kvs_.Init());
-
-  EXPECT_EQ(kvs_.PendingCleanCount(), 1u);
-
-  bool all_sectors_have_been_cleaned = false;
-  ASSERT_EQ(Status::OK, kvs_.CleanOneSector(&all_sectors_have_been_cleaned));
-  EXPECT_EQ(all_sectors_have_been_cleaned, true);
-  EXPECT_EQ(kvs_.PendingCleanCount(), 0u);
-  ASSERT_EQ(Status::OK, kvs_.CleanOneSector(&all_sectors_have_been_cleaned));
-  EXPECT_EQ(all_sectors_have_been_cleaned, true);
-  int value;
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &value));
-  ASSERT_EQ(values[0], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[1], &value));
-  ASSERT_EQ(values[1], value);
-  ASSERT_EQ(Status::OK, kvs_.Get(keys[2], &value));
-  ASSERT_EQ(values[2], value);
-#endif
-}
-
-TEST_F(EmptyInitializedKvs, DISABLED_CleanOneSector) {
-  if (CurrentTaskStackFree() < sizeof(KeyValueStore)) {
-    PW_LOG_ERROR("Not enough stack for test, skipping");
-    return;
-  }
-  StackHeavyCleanOneSector();
+  EXPECT_EQ(crc, checksum::CcittCrc16(test_flash.buffer()));
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index 93ee1eb..05b823f 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -203,7 +203,7 @@
   //          TIMEOUT, on timeout.
   //          INVALID_ARGUMENT, if address or length is invalid.
   //          UNKNOWN, on HAL error
-  // TODO: StatusWithBool
+  // TODO: Result<bool>
   virtual Status IsRegionErased(Address source_flash_address,
                                 size_t len,
                                 bool* is_erased);
diff --git a/pw_kvs/public/pw_kvs/key_value_store.h b/pw_kvs/public/pw_kvs/key_value_store.h
index acd0955..666dd6f 100644
--- a/pw_kvs/public/pw_kvs/key_value_store.h
+++ b/pw_kvs/public/pw_kvs/key_value_store.h
@@ -78,6 +78,7 @@
   // value can be read by calling get with an offset.
   //
   //                    OK: the entry was successfully read
+  //             NOT_FOUND: the key is not present in the KVS
   //             DATA_LOSS: found the entry, but the data was corrupted
   //    RESOURCE_EXHAUSTED: the buffer could not fit the entire value, but as
   //                        many bytes as possible were written to it
@@ -120,6 +121,7 @@
   //
   Status Put(std::string_view key, span<const std::byte> value);
 
+  // Adds a key-value entry to the KVS, using an object as the value.
   template <typename T,
             typename = std::enable_if_t<std::is_trivially_copyable_v<T> &&
                                         !std::is_pointer_v<T> &&
@@ -128,8 +130,25 @@
     return Put(key, as_bytes(span(&value, 1)));
   }
 
+  // Removes a key-value entry from the KVS.
+  //
+  //                    OK: the entry was successfully added or updated
+  //             NOT_FOUND: the key is not present in the KVS
+  //             DATA_LOSS: checksum validation failed after recording the erase
+  //    RESOURCE_EXHAUSTED: insufficient space to mark the entry as deleted
+  //   FAILED_PRECONDITION: the KVS is not initialized
+  //      INVALID_ARGUMENT: key is empty or too long
+  //
   Status Delete(std::string_view key);
 
+  // Returns the size of the value corresponding to the key.
+  //
+  //                    OK: the size was returned successfully
+  //             NOT_FOUND: the key is not present in the KVS
+  //             DATA_LOSS: checksum validation failed after reading the entry
+  //   FAILED_PRECONDITION: the KVS is not initialized
+  //      INVALID_ARGUMENT: key is empty or too long
+  //
   StatusWithSize ValueSize(std::string_view key) const;
 
   void LogDebugInfo();