diff --git a/centipede/BUILD b/centipede/BUILD
index 90f90a7..0d82b62 100644
--- a/centipede/BUILD
+++ b/centipede/BUILD
@@ -1022,6 +1022,7 @@
         ":execution_result",
         ":feature",
         ":shared_memory_blob_sequence",
+        ":test_util",
         "@com_google_googletest//:gtest_main",
     ],
 )
diff --git a/centipede/execution_result_test.cc b/centipede/execution_result_test.cc
index 25dcaf1..7ccf5a2 100644
--- a/centipede/execution_result_test.cc
+++ b/centipede/execution_result_test.cc
@@ -14,15 +14,17 @@
 
 #include "./centipede/execution_result.h"
 
-#include <unistd.h>
-
+#include <cstdint>
+#include <fstream>
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "./centipede/feature.h"
 #include "./centipede/shared_memory_blob_sequence.h"
+#include "./centipede/test_util.h"
 
 namespace centipede {
 namespace {
@@ -87,5 +89,70 @@
   batch_result.ClearAndResize(1);
   EXPECT_FALSE(batch_result.Read(blobseq));
 }
+
+TEST(ExecutionResult, WriteIntoFileThenRead) {
+  const std::string temp_file =
+      std::filesystem::path(GetTestTempDir()).append(test_info_->name());
+  std::ofstream output_stream(temp_file, std::ios::out);
+  ASSERT_TRUE(output_stream.is_open());
+
+  // Imitate execution of two inputs.
+  FeatureVec v1{1, 2, 3};
+  FeatureVec v2{5, 6, 7, 8};
+  ExecutionResult::Stats stats1{.peak_rss_mb = 10};
+  ExecutionResult::Stats stats2{.peak_rss_mb = 20};
+  ExecutionMetadata metadata;
+  metadata.AppendCmpEntry({1, 2, 3}, {4, 5, 6});
+
+  std::vector<uint8_t> buffer1(1000);
+  BlobSequence blobseq1(buffer1.data(), buffer1.size());
+  // First input.
+  ASSERT_TRUE(BatchResult::WriteInputBegin(blobseq1));
+  ASSERT_TRUE(BatchResult::WriteOneFeatureVec(v1.data(), v1.size(), blobseq1));
+  // Write stats after features. The order should not matter.
+  ASSERT_TRUE(BatchResult::WriteStats(stats1, blobseq1));
+  // Done.
+  ASSERT_TRUE(BatchResult::WriteInputEnd(blobseq1));
+
+  output_stream.write(reinterpret_cast<char*>(buffer1.data()),
+                      blobseq1.offset());
+
+  std::vector<uint8_t> buffer2(1000);
+  BlobSequence blobseq2(buffer2.data(), buffer2.size());
+  // Second input.
+  ASSERT_TRUE(BatchResult::WriteInputBegin(blobseq2));
+  // Write stats before features.
+  ASSERT_TRUE(BatchResult::WriteStats(stats2, blobseq2));
+  ASSERT_TRUE(BatchResult::WriteOneFeatureVec(v2.data(), v2.size(), blobseq2));
+  // Write CMP traces.
+  EXPECT_TRUE(BatchResult::WriteMetadata(metadata, blobseq2));
+  // Done.
+  ASSERT_TRUE(BatchResult::WriteInputEnd(blobseq2));
+
+  output_stream.write(reinterpret_cast<char*>(buffer2.data()),
+                      blobseq2.offset());
+
+  output_stream.close();
+
+  std::ifstream input_stream(temp_file);
+  std::string content((std::istreambuf_iterator<char>(input_stream)),
+                      (std::istreambuf_iterator<char>()));
+  BlobSequence blobseq(reinterpret_cast<uint8_t*>(content.data()),
+                       content.size());
+  BatchResult batch_result;
+  batch_result.ClearAndResize(2);
+  ASSERT_TRUE(batch_result.Read(blobseq));
+  EXPECT_EQ(batch_result.num_outputs_read(), 2);
+  EXPECT_EQ(batch_result.results()[0].features(), v1);
+  EXPECT_EQ(batch_result.results()[1].features(), v2);
+  EXPECT_EQ(batch_result.results()[0].stats(), stats1);
+  EXPECT_EQ(batch_result.results()[1].stats(), stats2);
+  EXPECT_THAT(batch_result.results()[1].metadata().cmp_data,
+              testing::ElementsAre(3,        // size
+                                   1, 2, 3,  // cmp0
+                                   4, 5, 6   // cmp1
+                                   ));
+}
+
 }  // namespace
 }  // namespace centipede
diff --git a/centipede/shared_memory_blob_sequence.cc b/centipede/shared_memory_blob_sequence.cc
index 2bcc620..dd6b378 100644
--- a/centipede/shared_memory_blob_sequence.cc
+++ b/centipede/shared_memory_blob_sequence.cc
@@ -68,7 +68,7 @@
 Blob BlobSequence::Read() {
   ErrorOnFailure(had_writes_after_reset_, "Had writes after reset");
   had_reads_after_reset_ = true;
-  if (offset_ + sizeof(Blob::size) + sizeof(Blob::tag) >= size_) return {};
+  if (offset_ + sizeof(Blob::size) + sizeof(Blob::tag) > size_) return {};
   // Read blob_tag.
   Blob::SizeAndTagT blob_tag = 0;
   memcpy(&blob_tag, data_ + offset_, sizeof(blob_tag));
diff --git a/centipede/shared_memory_blob_sequence_test.cc b/centipede/shared_memory_blob_sequence_test.cc
index 1ac1492..37e5c66 100644
--- a/centipede/shared_memory_blob_sequence_test.cc
+++ b/centipede/shared_memory_blob_sequence_test.cc
@@ -43,6 +43,16 @@
   return {tag, vec.size(), vec.data()};
 }
 
+TEST(BlobSequence, WriteAndReadAnEmptyBlob) {
+  std::vector<uint8_t> buffer(1000);
+  BlobSequence blobseq1(buffer.data(), buffer.size());
+  ASSERT_TRUE(blobseq1.Write(Blob(/*vec=*/{}, /*tag=*/1)));
+  BlobSequence blobseq2(buffer.data(), blobseq1.offset());
+  auto blob = blobseq2.Read();
+  EXPECT_EQ(Vec(blob).size(), 0);
+  EXPECT_EQ(blob.tag, 1);
+}
+
 TEST(SharedMemoryBlobSequence, ParentChild) {
   std::vector<uint8_t> kTestData1 = {1, 2, 3};
   std::vector<uint8_t> kTestData2 = {4, 5, 6, 7};