test: improve heap_table branch coverage

include/storage/buffer_pool_manager.hpp

@@ -106,6 +106,8 @@ class BufferPoolManager {
 
     bool close_file(const std::string& file_name) { return storage_manager_.close_file(file_name); }
 
+    bool delete_file(const std::string& file_name);
+
     /**
      * @brief Flush all pages in the pool to disk
      */

include/storage/heap_table.hpp

@@ -276,8 +276,16 @@ class HeapTable {
     /** @brief Removes the physical heap file */
     bool drop();
 
-   private:
+    /**
+     * @brief Read a page from the heap file into buffer
+     * @note Bypasses MVCC and cached_page_ invariants — test use only
+     */
     bool read_page(uint32_t page_num, char* buffer) const;
+
+    /**
+     * @brief Write a buffer into a page of the heap file
+     * @note Bypasses MVCC and cached_page_ invariants — test use only
+     */
     bool write_page(uint32_t page_num, const char* buffer);
 };
 

include/storage/storage_manager.hpp

@@ -102,6 +102,13 @@ class StorageManager {
      */
     bool create_dir_if_not_exists();
 
+    /**
+     * @brief Delete a file from storage
+     * @param filename The relative name of the file
+     * @return true if deleted, false otherwise
+     */
+    bool delete_file(const std::string& filename);
+
    private:
     std::string data_dir_;
     std::unordered_map<std::string, std::unique_ptr<std::fstream>> open_files_;

src/storage/buffer_pool_manager.cpp

@@ -227,6 +227,43 @@ bool BufferPoolManager::delete_page(const std::string& file_name, uint32_t page_
     return true;
 }
 
+bool BufferPoolManager::delete_file(const std::string& file_name) {
+    {
+        const std::scoped_lock<std::mutex> lock(latch_);
+
+        const uint32_t file_id = get_file_id_internal(file_name);
+
+        // Evict all pages belonging to this file
+        for (auto it = page_table_.begin(); it != page_table_.end();) {
+            if (it->first.file_id == file_id) {
+                const uint32_t frame_id = it->second;
+                Page* const page = &pages_[frame_id];
+                if (page->pin_count_ > 0) {
+                    return false;  // Cannot delete while pages are pinned
+                }
+                // Flush dirty pages before removing
+                if (page->is_dirty_) {
+                    storage_manager_.write_page(file_name, page->page_id_, page->get_data());
+                    page->is_dirty_ = false;
+                }
+                replacer_.pin(frame_id);
+                page->page_id_ = 0;
+                page->file_name_ = "";
+                page->pin_count_ = 0;
+                free_list_.push_back(frame_id);
+                it = page_table_.erase(it);
+            } else {
+                ++it;
+            }
+        }
+
+        // Remove file_id mapping
+        file_id_map_.erase(file_name);
+    }
+
+    return storage_manager_.delete_file(file_name);
+}
+
 void BufferPoolManager::flush_all_pages() {
     const std::scoped_lock<std::mutex> lock(latch_);
 

src/storage/heap_table.cpp

@@ -740,12 +740,15 @@ bool HeapTable::create() {
 }
 
 bool HeapTable::drop() {
+    // Unpin the insert-cached page (is_dirty=false since we're dropping the table)
+    // Note: this is asymmetric with the destructor which uses is_dirty=true -
+    // here we skip writes since the entire file will be deleted anyway.
     if (cached_page_ != nullptr) {
         bpm_.unpin_page_by_id(file_id_, cached_page_id_, false);
         cached_page_ = nullptr;
     }
     static_cast<void>(bpm_.close_file(filename_));
-    return (std::remove(filename_.c_str()) == 0);
+    return bpm_.delete_file(filename_);
 }
 
 bool HeapTable::read_page(uint32_t page_num, char* buffer) const {

src/storage/storage_manager.cpp

@@ -215,6 +215,22 @@ bool StorageManager::create_dir_if_not_exists() {
     return true;
 }
 
+/**
+ * @brief Delete a file from storage
+ */
+bool StorageManager::delete_file(const std::string& filename) {
+    // Close any open handle first to avoid stale fstream issues
+    auto it = open_files_.find(filename);
+    if (it != open_files_.end()) {
+        if (it->second->is_open()) {
+            it->second->close();
+        }
+        open_files_.erase(it);
+    }
+    const std::string filepath = get_full_path(filename);
+    return std::remove(filepath.c_str()) == 0;
+}
+
 }  // namespace cloudsql::storage
 
 /** @} */