gc v2 tests (#512)

* set MaxBlockCount at init 
* properly calculate total size
* basic blockstore compact blocks test
* correct detection of block swap
* Use one implementation for CreateRandomBlob
* reduce some data sets to increase speed of tests
* reduce test time
* rename BlockStoreCompactState::AddBlock -> BlockStoreCompactState::IncludeBlock

5 files changed, 328 insertions, 85 deletions

diff --git a/src/zenstore/blockstore.cpp b/src/zenstore/blockstore.cpp
index 837185201..30a659784 100644
--- a/src/zenstore/blockstore.cpp
+++ b/src/zenstore/blockstore.cpp
@@ -173,6 +173,7 @@ BlockStore::Initialize(const std::filesystem::path& BlocksBasePath, uint64_t Max
 	m_TotalSize		 = 0;
 	m_BlocksBasePath = BlocksBasePath;
 	m_MaxBlockSize	 = MaxBlockSize;
+	m_MaxBlockCount	 = MaxBlockCount;
 
 	if (std::filesystem::is_directory(m_BlocksBasePath))
 	{
@@ -322,9 +323,10 @@ BlockStore::WriteChunk(const void* Data, uint64_t Size, uint64_t Alignment, cons
 
 	RwLock::ExclusiveLockScope InsertLock(m_InsertLock);
 
-	uint32_t WriteBlockIndex = m_WriteBlockIndex.load(std::memory_order_acquire);
-	bool	 IsWriting		 = !!m_WriteBlock;
-	if (!IsWriting || (m_CurrentInsertOffset + Size) > m_MaxBlockSize)
+	uint32_t WriteBlockIndex	 = m_WriteBlockIndex.load(std::memory_order_acquire);
+	bool	 IsWriting			 = !!m_WriteBlock;
+	uint64_t AlignedInsertOffset = RoundUp(m_CurrentInsertOffset, Alignment);
+	if (!IsWriting || (AlignedInsertOffset + Size) > m_MaxBlockSize)
 	{
 		if (m_WriteBlock)
 		{
@@ -347,18 +349,18 @@ BlockStore::WriteChunk(const void* Data, uint64_t Size, uint64_t Alignment, cons
 		m_WriteBlock				   = NewBlockFile;
 		m_WriteBlockIndex.store(WriteBlockIndex, std::memory_order_release);
 		m_CurrentInsertOffset = 0;
+		AlignedInsertOffset	  = 0;
 	}
-	uint64_t InsertOffset				 = m_CurrentInsertOffset;
-	m_CurrentInsertOffset				 = RoundUp(InsertOffset + Size, Alignment);
-	uint64_t			AlignedWriteSize = m_CurrentInsertOffset - InsertOffset;
-	Ref<BlockStoreFile> WriteBlock		 = m_WriteBlock;
+	uint64_t AlignedWriteSize	   = AlignedInsertOffset - m_CurrentInsertOffset + Size;
+	m_CurrentInsertOffset		   = AlignedInsertOffset + Size;
+	Ref<BlockStoreFile> WriteBlock = m_WriteBlock;
 	m_ActiveWriteBlocks.push_back(WriteBlockIndex);
 	InsertLock.ReleaseNow();
 
-	WriteBlock->Write(Data, Size, InsertOffset);
+	WriteBlock->Write(Data, Size, AlignedInsertOffset);
 	m_TotalSize.fetch_add(AlignedWriteSize, std::memory_order::relaxed);
 
-	Callback({.BlockIndex = WriteBlockIndex, .Offset = InsertOffset, .Size = Size});
+	Callback({.BlockIndex = WriteBlockIndex, .Offset = AlignedInsertOffset, .Size = Size});
 
 	{
 		RwLock::ExclusiveLockScope _(m_InsertLock);
@@ -1003,12 +1005,15 @@ BlockStore::CompactBlocks(const BlockStoreCompactState&	  CompactState,
 
 	CompactState.IterateBlocks(
 		[&](uint32_t BlockIndex, const std::vector<size_t>& KeepChunkIndexes, const std::vector<BlockStoreLocation>& ChunkLocations) {
-			ZEN_ASSERT(BlockIndex != m_WriteBlockIndex.load());
-
 			Ref<BlockStoreFile> OldBlockFile;
 			{
 				RwLock::SharedLockScope _(m_InsertLock);
-				auto					It = m_ChunkBlocks.find(BlockIndex);
+				if ((BlockIndex == m_WriteBlockIndex.load()) && m_WriteBlock)
+				{
+					// You are trying to collect the currently writing block, Report error?
+					return;
+				}
+				auto It = m_ChunkBlocks.find(BlockIndex);
 				if (It == m_ChunkBlocks.end())
 				{
 					// This block has unknown, we can't move anything. Report error?
@@ -1320,21 +1325,6 @@ namespace blockstore::impl {
 		return Result;
 	};
 
-	static IoBuffer CreateChunk(uint64_t Size)
-	{
-		static std::random_device rd;
-		static std::mt19937		  g(rd());
-
-		std::vector<uint8_t> Values;
-		Values.resize(Size);
-		for (size_t Idx = 0; Idx < Size; ++Idx)
-		{
-			Values[Idx] = static_cast<uint8_t>(Idx);
-		}
-		std::shuffle(Values.begin(), Values.end(), g);
-
-		return IoBufferBuilder::MakeCloneFromMemory(Values.data(), Values.size());
-	}
 }  // namespace blockstore::impl
 
 TEST_CASE("blockstore.chunks")
@@ -1546,7 +1536,7 @@ TEST_CASE("blockstore.reclaim.space")
 	ChunkHashes.reserve(ChunkCount);
 	for (size_t ChunkIndex = 0; ChunkIndex < ChunkCount; ++ChunkIndex)
 	{
-		IoBuffer Chunk = CreateChunk(57 + ChunkIndex);
+		IoBuffer Chunk = CreateRandomBlob(57 + ChunkIndex);
 
 		Store.WriteChunk(Chunk.Data(), Chunk.Size(), Alignment, [&](const BlockStoreLocation& L) { ChunkLocations.push_back(L); });
 		ChunkHashes.push_back(IoHash::HashBuffer(Chunk.Data(), Chunk.Size()));
@@ -1665,7 +1655,7 @@ TEST_CASE("blockstore.thread.read.write")
 	ChunkHashes.reserve(ChunkCount);
 	for (size_t ChunkIndex = 0; ChunkIndex < ChunkCount; ++ChunkIndex)
 	{
-		IoBuffer Chunk = CreateChunk(57 + ChunkIndex / 2);
+		IoBuffer Chunk = CreateRandomBlob(57 + ChunkIndex / 2);
 		Chunks.push_back(Chunk);
 		ChunkHashes.push_back(IoHash::HashBuffer(Chunk.Data(), Chunk.Size()));
 	}
@@ -1730,6 +1720,293 @@ TEST_CASE("blockstore.thread.read.write")
 	}
 }
 
+TEST_CASE("blockstore.compact.blocks")
+{
+	using namespace blockstore::impl;
+
+	ScopedTemporaryDirectory TempDir;
+	auto					 RootDirectory = TempDir.Path();
+
+	BlockStore Store;
+	Store.Initialize(RootDirectory / "store", 1088, 1024);
+
+	constexpr size_t	  ChunkCount = 200;
+	constexpr size_t	  Alignment	 = 8;
+	std::vector<IoBuffer> Chunks;
+	std::vector<IoHash>	  ChunkHashes;
+	Chunks.reserve(ChunkCount);
+	ChunkHashes.reserve(ChunkCount);
+	for (size_t ChunkIndex = 0; ChunkIndex < ChunkCount; ++ChunkIndex)
+	{
+		IoBuffer Chunk = CreateRandomBlob(57 + ChunkIndex / 2);
+		Chunks.push_back(Chunk);
+		ChunkHashes.push_back(IoHash::HashBuffer(Chunk.Data(), Chunk.Size()));
+	}
+
+	std::vector<BlockStoreLocation> ChunkLocations;
+	ChunkLocations.resize(ChunkCount);
+
+	for (size_t ChunkIndex = 0; ChunkIndex < ChunkCount; ++ChunkIndex)
+	{
+		IoBuffer& Chunk = Chunks[ChunkIndex];
+		Store.WriteChunk(Chunk.Data(), Chunk.Size(), Alignment, [&](const BlockStoreLocation& L) { ChunkLocations[ChunkIndex] = L; });
+	}
+
+	SUBCASE("touch nothing")
+	{
+		uint64_t PreSize = Store.TotalSize();
+		CHECK(PreSize > 0);
+		BlockStoreCompactState State;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray&, uint64_t) { CHECK(false); },
+			[]() {
+				CHECK(false);
+				return 0;
+			});
+		CHECK_EQ(PreSize, Store.TotalSize());
+	}
+	SUBCASE("keep nothing")
+	{
+		Store.Flush(true);
+
+		uint64_t PreSize = Store.TotalSize();
+		CHECK(PreSize > 0);
+		BlockStoreCompactState State;
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			State.IncludeBlock(Location.BlockIndex);
+		}
+		uint64_t RemovedSize = 0;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray& Moved, uint64_t Removed) {
+				RemovedSize += Removed;
+				CHECK(Moved.empty());
+			},
+			[]() { return 0; });
+		CHECK_EQ(RemovedSize, PreSize);
+		CHECK_EQ(0u, Store.TotalSize());
+	}
+	SUBCASE("keep current write block")
+	{
+		uint64_t						 PreSize = Store.TotalSize();
+		BlockStoreCompactState			 State;
+		BlockStore::ReclaimSnapshotState SnapshotState = Store.GetReclaimSnapshotState();
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			if (SnapshotState.m_ActiveWriteBlocks.contains(Location.BlockIndex))
+			{
+				continue;
+			}
+			State.IncludeBlock(Location.BlockIndex);
+		}
+		uint64_t RemovedSize = 0;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray& Moved, uint64_t Removed) {
+				RemovedSize += Removed;
+				CHECK(Moved.empty());
+			},
+			[]() { return 0; });
+		CHECK_EQ(Store.TotalSize() + RemovedSize, PreSize);
+		CHECK_LE(Store.TotalSize(), 1088);
+		CHECK_GT(Store.TotalSize(), 0);
+	}
+	SUBCASE("keep everthing")
+	{
+		Store.Flush(true);
+
+		uint64_t						 PreSize = Store.TotalSize();
+		BlockStoreCompactState			 State;
+		BlockStore::ReclaimSnapshotState SnapshotState = Store.GetReclaimSnapshotState();
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			State.AddKeepLocation(Location);
+		}
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray&, uint64_t) { CHECK(false); },
+			[]() {
+				CHECK(false);
+				return 0;
+			});
+		CHECK_EQ(Store.TotalSize(), PreSize);
+	}
+	SUBCASE("drop first block")
+	{
+		uint64_t						 PreSize = Store.TotalSize();
+		BlockStoreCompactState			 State;
+		BlockStore::ReclaimSnapshotState SnapshotState = Store.GetReclaimSnapshotState();
+
+		CHECK(!SnapshotState.m_ActiveWriteBlocks.contains(0));
+		State.IncludeBlock(0);
+
+		uint64_t FirstBlockSize = 0;
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			if (Location.BlockIndex == 0)
+			{
+				FirstBlockSize = Max<uint64_t>(FirstBlockSize, Location.Offset + Location.Size);
+			}
+		}
+
+		uint64_t RemovedSize = 0;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray& Moved, uint64_t Removed) {
+				CHECK(Moved.empty());
+				RemovedSize += Removed;
+			},
+			[]() {
+				CHECK(false);
+				return 0;
+			});
+		CHECK_EQ(FirstBlockSize, RemovedSize);
+		CHECK_EQ(Store.TotalSize(), PreSize - FirstBlockSize);
+	}
+	SUBCASE("compact first block")
+	{
+		uint64_t						 PreSize = Store.TotalSize();
+		BlockStoreCompactState			 State;
+		BlockStore::ReclaimSnapshotState SnapshotState = Store.GetReclaimSnapshotState();
+
+		CHECK(!SnapshotState.m_ActiveWriteBlocks.contains(0));
+		State.IncludeBlock(0);
+
+		uint64_t						SkipChunkCount = 2;
+		std::vector<BlockStoreLocation> DroppedLocations(ChunkLocations.begin(), ChunkLocations.begin() + 2);
+		for (auto It = ChunkLocations.begin() + 2; It != ChunkLocations.end(); It++)
+		{
+			const BlockStoreLocation& Location = *It;
+			if (Location.BlockIndex != 0)
+			{
+				continue;
+			}
+			State.AddKeepLocation(Location);
+		}
+		uint64_t RemovedSize = 0;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray& Moved, uint64_t Removed) {
+				for (const auto& Move : Moved)
+				{
+					const BlockStoreLocation& OldLocation = State.GetLocation(Move.first);
+					CHECK(OldLocation.BlockIndex == 0);	 // Only move from block 0
+					CHECK(std::find(DroppedLocations.begin(), DroppedLocations.end(), OldLocation) == DroppedLocations.end());
+					auto It = std::find(ChunkLocations.begin(), ChunkLocations.end(), OldLocation);
+					CHECK(It != ChunkLocations.end());
+					(*It) = Move.second;
+				}
+				RemovedSize += Removed;
+			},
+			[]() {
+				CHECK(false);
+				return 0;
+			});
+
+		SkipChunkCount = 2;
+
+		for (size_t Index = 0; Index < ChunkLocations.size(); Index++)
+		{
+			const BlockStoreLocation& Location = ChunkLocations[Index];
+			if (Location.BlockIndex == 0 && SkipChunkCount > 0)
+			{
+				CHECK(!Store.TryGetChunk(Location));
+				continue;
+			}
+			IoBuffer Buffer = Store.TryGetChunk(Location);
+			CHECK(Buffer);
+			IoHash RawHash = IoHash::HashBuffer(Buffer.Data(), Buffer.Size());
+			CHECK_EQ(ChunkHashes[Index], RawHash);
+		}
+		CHECK_LT(Store.TotalSize(), PreSize);
+	}
+	SUBCASE("compact every other item")
+	{
+		uint64_t						 PreSize = Store.TotalSize();
+		BlockStoreCompactState			 State;
+		BlockStore::ReclaimSnapshotState SnapshotState = Store.GetReclaimSnapshotState();
+		bool							 SkipFlag	   = false;
+
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			if (SnapshotState.m_ActiveWriteBlocks.contains(Location.BlockIndex))
+			{
+				continue;
+			}
+			if (SkipFlag)
+			{
+				State.IncludeBlock(Location.BlockIndex);
+				SkipFlag = false;
+				continue;
+			}
+			SkipFlag = true;
+		}
+
+		SkipFlag = false;
+		std::vector<BlockStoreLocation> DroppedLocations;
+		for (const BlockStoreLocation& Location : ChunkLocations)
+		{
+			if (SnapshotState.m_ActiveWriteBlocks.contains(Location.BlockIndex))
+			{
+				continue;
+			}
+			if (SkipFlag)
+			{
+				DroppedLocations.push_back(Location);
+				SkipFlag = false;
+				continue;
+			}
+			State.AddKeepLocation(Location);
+			SkipFlag = true;
+		}
+		uint64_t RemovedSize = 0;
+		Store.CompactBlocks(
+			State,
+			Alignment,
+			[&](const BlockStore::MovedChunksArray& Moved, uint64_t Removed) {
+				for (const auto& Move : Moved)
+				{
+					const BlockStoreLocation& OldLocation = State.GetLocation(Move.first);
+					CHECK(std::find(DroppedLocations.begin(), DroppedLocations.end(), OldLocation) == DroppedLocations.end());
+					auto It = std::find(ChunkLocations.begin(), ChunkLocations.end(), OldLocation);
+					CHECK(It != ChunkLocations.end());
+					(*It) = Move.second;
+				}
+				RemovedSize += Removed;
+			},
+			[]() {
+				CHECK(false);
+				return 0;
+			});
+		SkipFlag = false;
+		for (size_t Index = 0; Index < ChunkLocations.size(); Index++)
+		{
+			const BlockStoreLocation& Location = ChunkLocations[Index];
+			if (SkipFlag && !SnapshotState.m_ActiveWriteBlocks.contains(Location.BlockIndex))
+			{
+				CHECK(std::find(DroppedLocations.begin(), DroppedLocations.end(), Location) != DroppedLocations.end());
+				CHECK(!Store.TryGetChunk(Location));
+				SkipFlag = false;
+				continue;
+			}
+			IoBuffer Buffer = Store.TryGetChunk(Location);
+			CHECK(Buffer);
+			IoHash RawHash = IoHash::HashBuffer(Buffer.Data(), Buffer.Size());
+			CHECK_EQ(ChunkHashes[Index], RawHash);
+			SkipFlag = true;
+		}
+		CHECK_LT(Store.TotalSize(), PreSize);
+	}
+}
+
 #endif
 
 void
diff --git a/src/zenstore/compactcas.cpp b/src/zenstore/compactcas.cpp
index 655c0558d..de2800895 100644
--- a/src/zenstore/compactcas.cpp
+++ b/src/zenstore/compactcas.cpp
@@ -701,7 +701,7 @@ public:
 					bool	 IsActiveWriteBlock = BlockSnapshotState.m_ActiveWriteBlocks.contains(BlockIndex);
 					if (!IsActiveWriteBlock)
 					{
-						CompactState.AddBlock(BlockIndex);
+						CompactState.IncludeBlock(BlockIndex);
 					}
 					ExpiredEntries.push_back(ExpiredEntry);
 				}
@@ -1099,24 +1099,6 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 
 #if ZEN_WITH_TESTS
 
-namespace {
-	static IoBuffer CreateRandomChunk(uint64_t Size)
-	{
-		static std::random_device rd;
-		static std::mt19937		  g(rd());
-
-		std::vector<uint8_t> Values;
-		Values.resize(Size);
-		for (size_t Idx = 0; Idx < Size; ++Idx)
-		{
-			Values[Idx] = static_cast<uint8_t>(Idx);
-		}
-		std::shuffle(Values.begin(), Values.end(), g);
-
-		return IoBufferBuilder::MakeCloneFromMemory(Values.data(), Values.size());
-	}
-}  // namespace
-
 TEST_CASE("compactcas.hex")
 {
 	uint32_t	Value;
@@ -1233,7 +1215,7 @@ TEST_CASE("compactcas.compact.totalsize")
 
 			for (int32_t Idx = 0; Idx < kChunkCount; ++Idx)
 			{
-				IoBuffer			   Chunk		= CreateRandomChunk(kChunkSize);
+				IoBuffer			   Chunk		= CreateRandomBlob(kChunkSize);
 				const IoHash		   Hash			= HashBuffer(Chunk);
 				CasStore::InsertResult InsertResult = Cas.InsertChunk(Chunk, Hash);
 				ZEN_ASSERT(InsertResult.New);
@@ -1272,7 +1254,7 @@ TEST_CASE("compactcas.gc.basic")
 	CasContainerStrategy Cas(Gc);
 	Cas.Initialize(TempDir.Path(), "cb", 65536, 1 << 4, true);
 
-	IoBuffer Chunk	   = CreateRandomChunk(128);
+	IoBuffer Chunk	   = CreateRandomBlob(128);
 	IoHash	 ChunkHash = IoHash::HashBuffer(Chunk);
 
 	const CasStore::InsertResult InsertResult = Cas.InsertChunk(Chunk, ChunkHash);
@@ -1291,7 +1273,7 @@ TEST_CASE("compactcas.gc.removefile")
 {
 	ScopedTemporaryDirectory TempDir;
 
-	IoBuffer Chunk	   = CreateRandomChunk(128);
+	IoBuffer Chunk	   = CreateRandomBlob(128);
 	IoHash	 ChunkHash = IoHash::HashBuffer(Chunk);
 	{
 		GcManager			 Gc;
@@ -1331,7 +1313,7 @@ TEST_CASE("compactcas.gc.compact")
 		Chunks.reserve(9);
 		for (uint64_t Size : ChunkSizes)
 		{
-			Chunks.push_back(CreateRandomChunk(Size));
+			Chunks.push_back(CreateRandomBlob(Size));
 		}
 
 		std::vector<IoHash> ChunkHashes;
@@ -1568,7 +1550,7 @@ TEST_CASE("compactcas.gc.deleteblockonopen")
 	Chunks.reserve(20);
 	for (uint64_t Size : ChunkSizes)
 	{
-		Chunks.push_back(CreateRandomChunk(Size));
+		Chunks.push_back(CreateRandomBlob(Size));
 	}
 
 	std::vector<IoHash> ChunkHashes;
@@ -1634,7 +1616,7 @@ TEST_CASE("compactcas.gc.handleopeniobuffer")
 	Chunks.reserve(20);
 	for (const uint64_t& Size : ChunkSizes)
 	{
-		Chunks.push_back(CreateRandomChunk(Size));
+		Chunks.push_back(CreateRandomBlob(Size));
 	}
 
 	std::vector<IoHash> ChunkHashes;
@@ -1686,7 +1668,7 @@ TEST_CASE("compactcas.threadedinsert")
 		{
 			while (true)
 			{
-				IoBuffer Chunk = CreateRandomChunk(kChunkSize);
+				IoBuffer Chunk = CreateRandomBlob(kChunkSize);
 				IoHash	 Hash  = HashBuffer(Chunk);
 				if (Chunks.contains(Hash))
 				{
@@ -1755,7 +1737,7 @@ TEST_CASE("compactcas.threadedinsert")
 
 			for (int32_t Idx = 0; Idx < kChunkCount; ++Idx)
 			{
-				IoBuffer Chunk	= CreateRandomChunk(kChunkSize);
+				IoBuffer Chunk	= CreateRandomBlob(kChunkSize);
 				IoHash	 Hash	= HashBuffer(Chunk);
 				NewChunks[Hash] = Chunk;
 				GcChunkHashes.insert(Hash);
diff --git a/src/zenstore/filecas.cpp b/src/zenstore/filecas.cpp
index c021e0e21..a72619e4b 100644
--- a/src/zenstore/filecas.cpp
+++ b/src/zenstore/filecas.cpp
@@ -1612,7 +1612,7 @@ TEST_CASE("cas.file.gc")
 	FileCasStrategy FileCas(Gc);
 	FileCas.Initialize(TempDir.Path() / "cas", /* IsNewStore */ true);
 
-	const int			kIterationCount = 1000;
+	const int			kIterationCount = 100;
 	std::vector<IoHash> Keys{kIterationCount};
 
 	auto InsertChunks = [&] {
diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index f319475f3..365eb10ab 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -1652,22 +1652,6 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 #if ZEN_WITH_TESTS
 
 namespace gc::impl {
-	static IoBuffer CreateChunk(uint64_t Size)
-	{
-		static std::random_device rd;
-		static std::mt19937		  g(rd());
-
-		std::vector<uint8_t> Values;
-		Values.resize(Size);
-		for (size_t Idx = 0; Idx < Size; ++Idx)
-		{
-			Values[Idx] = static_cast<uint8_t>(Idx);
-		}
-		std::shuffle(Values.begin(), Values.end(), g);
-
-		return IoBufferBuilder::MakeCloneFromMemory(Values.data(), Values.size());
-	}
-
 	static CompressedBuffer Compress(IoBuffer Buffer)
 	{
 		return CompressedBuffer::Compress(SharedBuffer::MakeView(Buffer.GetData(), Buffer.GetSize()));
@@ -1688,7 +1672,7 @@ TEST_CASE("gc.basic")
 
 	CidStore.Initialize(CasConfig);
 
-	IoBuffer Chunk			 = CreateChunk(128);
+	IoBuffer Chunk			 = CreateRandomBlob(128);
 	auto	 CompressedChunk = Compress(Chunk);
 
 	const auto InsertResult = CidStore.AddChunk(CompressedChunk.GetCompressed().Flatten().AsIoBuffer(), CompressedChunk.DecodeRawHash());
@@ -1718,15 +1702,15 @@ TEST_CASE("gc.full")
 	CasStore->Initialize(CasConfig);
 
 	uint64_t ChunkSizes[9]	= {128, 541, 1023, 781, 218, 37, 4, 997, 5};
-	IoBuffer Chunks[9]		= {CreateChunk(ChunkSizes[0]),
-						   CreateChunk(ChunkSizes[1]),
-						   CreateChunk(ChunkSizes[2]),
-						   CreateChunk(ChunkSizes[3]),
-						   CreateChunk(ChunkSizes[4]),
-						   CreateChunk(ChunkSizes[5]),
-						   CreateChunk(ChunkSizes[6]),
-						   CreateChunk(ChunkSizes[7]),
-						   CreateChunk(ChunkSizes[8])};
+	IoBuffer Chunks[9]		= {CreateRandomBlob(ChunkSizes[0]),
+						   CreateRandomBlob(ChunkSizes[1]),
+						   CreateRandomBlob(ChunkSizes[2]),
+						   CreateRandomBlob(ChunkSizes[3]),
+						   CreateRandomBlob(ChunkSizes[4]),
+						   CreateRandomBlob(ChunkSizes[5]),
+						   CreateRandomBlob(ChunkSizes[6]),
+						   CreateRandomBlob(ChunkSizes[7]),
+						   CreateRandomBlob(ChunkSizes[8])};
 	IoHash	 ChunkHashes[9] = {
 		  IoHash::HashBuffer(Chunks[0].Data(), Chunks[0].Size()),
 		  IoHash::HashBuffer(Chunks[1].Data(), Chunks[1].Size()),
@@ -2080,7 +2064,7 @@ TEST_CASE("scrub.basic")
 
 	CidStore.Initialize(CasConfig);
 
-	IoBuffer Chunk			 = CreateChunk(128);
+	IoBuffer Chunk			 = CreateRandomBlob(128);
 	auto	 CompressedChunk = Compress(Chunk);
 
 	const auto InsertResult = CidStore.AddChunk(CompressedChunk.GetCompressed().Flatten().AsIoBuffer(), CompressedChunk.DecodeRawHash());
diff --git a/src/zenstore/include/zenstore/blockstore.h b/src/zenstore/include/zenstore/blockstore.h
index cd475cd8b..75accd9b8 100644
--- a/src/zenstore/include/zenstore/blockstore.h
+++ b/src/zenstore/include/zenstore/blockstore.h
@@ -193,7 +193,7 @@ class BlockStoreCompactState
 public:
 	BlockStoreCompactState() = default;
 
-	void AddBlock(uint32_t BlockIndex)
+	void IncludeBlock(uint32_t BlockIndex)
 	{
 		auto It = m_BlockIndexToChunkMapIndex.find(BlockIndex);
 		if (It == m_BlockIndexToChunkMapIndex.end())