ramfs_test.cpp File Reference

#include "ramfs.hpp"
#include <gtest/gtest.h>
#include <vector>
#include "test_environment_state.hpp"

Include dependency graph for ramfs_test.cpp:

Go to the source code of this file.

Classes
class	RamFsTest

Functions
	TEST_F (RamFsTest, MountUnmount)
	TEST_F (RamFsTest, GetName)
	TEST_F (RamFsTest, GetRootInode)
	TEST_F (RamFsTest, AllocateInode)
	TEST_F (RamFsTest, CreateAndLookupFile)
	TEST_F (RamFsTest, CreateDirectory)
	TEST_F (RamFsTest, UnlinkFile)
	TEST_F (RamFsTest, Rmdir)
	TEST_F (RamFsTest, FileReadWrite)
	TEST_F (RamFsTest, FileSeek)
	TEST_F (RamFsTest, ReadDirectory)
	TEST_F (RamFsTest, CreateDuplicateFile)
	TEST_F (RamFsTest, RmdirNonEmpty)
	TEST_F (RamFsTest, UnlinkNonExistent)
	TEST_F (RamFsTest, Sync)

Function Documentation

TEST_F() [1/15]

TEST_F	(	RamFsTest	,
		AllocateInode
	)

Definition at line 52 of file ramfs_test.cpp.

                                 {
  // 分配多个 inode
  std::vector<Inode*> inodes;
  for (int i = 0; i < 10; ++i) {
    auto result = ramfs_.AllocateInode();
    EXPECT_TRUE(result.has_value());
    EXPECT_NE(result.value(), nullptr);
    inodes.push_back(result.value());
  }
 
  // 释放所有 inode
  for (auto* inode : inodes) {
    auto free_result = ramfs_.FreeInode(inode);
    EXPECT_TRUE(free_result.has_value());
  }
}

TEST_F() [2/15]

TEST_F	(	RamFsTest	,
		CreateAndLookupFile
	)

Definition at line 70 of file ramfs_test.cpp.

                                       {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
  ASSERT_NE(root->ops, nullptr);
 
  // 创建文件
  auto create_result =
      root->ops->Create(root, "testfile.txt", FileType::kRegular);
  EXPECT_TRUE(create_result.has_value());
 
  Inode* file_inode = create_result.value();
  EXPECT_NE(file_inode, nullptr);
  EXPECT_EQ(file_inode->type, FileType::kRegular);
 
  // 查找文件
  auto lookup_result = root->ops->Lookup(root, "testfile.txt");
  EXPECT_TRUE(lookup_result.has_value());
  EXPECT_EQ(lookup_result.value(), file_inode);
 
  // 查找不存在的文件
  lookup_result = root->ops->Lookup(root, "nonexistent.txt");
  EXPECT_FALSE(lookup_result.has_value());
}

Here is the call graph for this function:

TEST_F() [3/15]

TEST_F	(	RamFsTest	,
		CreateDirectory
	)

Definition at line 95 of file ramfs_test.cpp.

                                   {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
  ASSERT_NE(root->ops, nullptr);
 
  // 创建目录
  auto mkdir_result = root->ops->Mkdir(root, "testdir");
  EXPECT_TRUE(mkdir_result.has_value());
 
  Inode* dir_inode = mkdir_result.value();
  EXPECT_NE(dir_inode, nullptr);
  EXPECT_EQ(dir_inode->type, FileType::kDirectory);
}

Here is the call graph for this function:

TEST_F() [4/15]

TEST_F	(	RamFsTest	,
		CreateDuplicateFile
	)

Definition at line 242 of file ramfs_test.cpp.

                                       {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建文件
  auto create_result =
      root->ops->Create(root, "duplicate.txt", FileType::kRegular);
  EXPECT_TRUE(create_result.has_value());
 
  // 重复创建应该失败
  create_result = root->ops->Create(root, "duplicate.txt", FileType::kRegular);
  EXPECT_FALSE(create_result.has_value());
}

Here is the call graph for this function:

TEST_F() [5/15]

TEST_F	(	RamFsTest	,
		FileReadWrite
	)

Definition at line 147 of file ramfs_test.cpp.

                                 {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建文件
  auto create_result =
      root->ops->Create(root, "rwtest.txt", FileType::kRegular);
  ASSERT_TRUE(create_result.has_value());
 
  Inode* file_inode = create_result.value();
 
  // 创建 File 对象
  File file;
  file.inode = file_inode;
  file.offset = 0;
  file.ops = ramfs_.GetFileOps();
 
  // 写入数据
  const char* write_data = "Hello, RamFS!";
  size_t write_len = strlen(write_data);
 
  auto write_result = file.ops->Write(&file, write_data, write_len);
  EXPECT_TRUE(write_result.has_value());
  EXPECT_EQ(write_result.value(), write_len);
 
  // 重置偏移量并读取
  file.offset = 0;
  char read_buffer[64] = {0};
 
  auto read_result = file.ops->Read(&file, read_buffer, sizeof(read_buffer));
  EXPECT_TRUE(read_result.has_value());
  EXPECT_EQ(read_result.value(), write_len);
  EXPECT_STREQ(read_buffer, write_data);
}

Here is the call graph for this function:

TEST_F() [6/15]

TEST_F	(	RamFsTest	,
		FileSeek
	)

Definition at line 183 of file ramfs_test.cpp.

                            {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建文件并写入数据
  auto create_result =
      root->ops->Create(root, "seektest.txt", FileType::kRegular);
  ASSERT_TRUE(create_result.has_value());
 
  File file;
  file.inode = create_result.value();
  file.offset = 0;
  file.ops = ramfs_.GetFileOps();
 
  const char* data = "ABCDEFGHIJ";
  (void)file.ops->Write(&file, data, strlen(data));
 
  // SEEK_SET
  auto seek_result = file.ops->Seek(&file, 5, SeekWhence::kSet);
  EXPECT_TRUE(seek_result.has_value());
  EXPECT_EQ(seek_result.value(), 5u);
 
  // SEEK_CUR
  seek_result = file.ops->Seek(&file, 2, SeekWhence::kCur);
  EXPECT_TRUE(seek_result.has_value());
  EXPECT_EQ(seek_result.value(), 7u);
 
  // SEEK_END
  seek_result = file.ops->Seek(&file, -3, SeekWhence::kEnd);
  EXPECT_TRUE(seek_result.has_value());
  EXPECT_EQ(seek_result.value(), strlen(data) - 3);
}

Here is the call graph for this function:

TEST_F() [7/15]

TEST_F	(	RamFsTest	,
		GetName
	)

Definition at line 43 of file ramfs_test.cpp.

{ EXPECT_STREQ(ramfs_.GetName(), "ramfs"); }

TEST_F() [8/15]

TEST_F	(	RamFsTest	,
		GetRootInode
	)

Definition at line 45 of file ramfs_test.cpp.

                                {
  Inode* root = ramfs_.GetRootInode();
  EXPECT_NE(root, nullptr);
  EXPECT_EQ(root->type, FileType::kDirectory);
}

TEST_F() [9/15]

TEST_F	(	RamFsTest	,
		MountUnmount
	)

Definition at line 37 of file ramfs_test.cpp.

                                {
  // SetUp 中已经挂载，这里测试重复挂载
  auto result = ramfs_.Mount(nullptr);
  EXPECT_FALSE(result.has_value());  // 应该失败，因为已经挂载
}

TEST_F() [10/15]

TEST_F	(	RamFsTest	,
		ReadDirectory
	)

Definition at line 217 of file ramfs_test.cpp.

                                 {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建一些文件和目录
  (void)root->ops->Create(root, "file1.txt", FileType::kRegular);
  (void)root->ops->Create(root, "file2.txt", FileType::kRegular);
  (void)root->ops->Mkdir(root, "dir1");
 
  // 创建 File 对象用于 readdir
  File dir_file;
  dir_file.inode = root;
  dir_file.offset = 0;
  dir_file.ops = ramfs_.GetFileOps();
 
  DirEntry entries[16];
  auto readdir_result = dir_file.ops->ReadDir(&dir_file, entries, 16);
  EXPECT_TRUE(readdir_result.has_value());
 
  // 应该至少有 . 和 .. 加上我们创建的文件和目录
  size_t count = readdir_result.value();
  EXPECT_GE(count, 2u);  // 至少包含 . 和 ..
}

Here is the call graph for this function:

TEST_F() [11/15]

TEST_F	(	RamFsTest	,
		Rmdir
	)

Definition at line 129 of file ramfs_test.cpp.

                         {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建目录
  auto mkdir_result = root->ops->Mkdir(root, "dir_to_remove");
  ASSERT_TRUE(mkdir_result.has_value());
 
  // 删除目录
  auto rmdir_result = root->ops->Rmdir(root, "dir_to_remove");
  EXPECT_TRUE(rmdir_result.has_value());
 
  // 确认目录已删除
  auto lookup_result = root->ops->Lookup(root, "dir_to_remove");
  EXPECT_FALSE(lookup_result.has_value());
}

Here is the call graph for this function:

TEST_F() [12/15]

TEST_F	(	RamFsTest	,
		RmdirNonEmpty
	)

Definition at line 257 of file ramfs_test.cpp.

                                 {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 创建目录
  auto mkdir_result = root->ops->Mkdir(root, "nonempty_dir");
  ASSERT_TRUE(mkdir_result.has_value());
 
  Inode* dir = mkdir_result.value();
 
  // 在目录中创建文件
  (void)dir->ops->Create(dir, "file_inside.txt", FileType::kRegular);
 
  // 尝试删除非空目录应该失败
  auto rmdir_result = root->ops->Rmdir(root, "nonempty_dir");
  EXPECT_FALSE(rmdir_result.has_value());
}

Here is the call graph for this function:

TEST_F() [13/15]

TEST_F	(	RamFsTest	,
		Sync
	)

Definition at line 285 of file ramfs_test.cpp.

                        {
  auto sync_result = ramfs_.Sync();
  EXPECT_TRUE(sync_result.has_value());
}

TEST_F() [14/15]

TEST_F	(	RamFsTest	,
		UnlinkFile
	)

Definition at line 110 of file ramfs_test.cpp.

                              {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  // 先创建文件
  auto create_result =
      root->ops->Create(root, "todelete.txt", FileType::kRegular);
  ASSERT_TRUE(create_result.has_value());
 
  // 删除文件
  auto unlink_result = root->ops->Unlink(root, "todelete.txt");
  EXPECT_TRUE(unlink_result.has_value());
 
  // 确认文件已删除
  auto lookup_result = root->ops->Lookup(root, "todelete.txt");
  EXPECT_FALSE(lookup_result.has_value());
}

Here is the call graph for this function:

TEST_F() [15/15]

TEST_F	(	RamFsTest	,
		UnlinkNonExistent
	)

Definition at line 276 of file ramfs_test.cpp.

                                     {
  Inode* root = ramfs_.GetRootInode();
  ASSERT_NE(root, nullptr);
 
  auto unlink_result = root->ops->Unlink(root, "nonexistent.txt");
  EXPECT_FALSE(unlink_result.has_value());
}

Here is the call graph for this function: