vfs_test.cpp File Reference

#include "vfs.hpp"
#include <gtest/gtest.h>
#include "file_descriptor.hpp"
#include "filesystem.hpp"
#include "mount.hpp"
#include "test_environment_state.hpp"

Include dependency graph for vfs_test.cpp:

Go to the source code of this file.

Classes
class	MockFileOps
class	MockFs
class	VfsTest
class	BaseEnvTest
class	MountTableTest
class	FdTableTest
class	VfsInitTest

Functions
	TEST_F (MountTableTest, MountAndUnmount)
	TEST_F (MountTableTest, LookupMountPoint)
	TEST_F (FdTableTest, AllocAndFree)
	TEST_F (FdTableTest, InvalidFd)
	TEST_F (FdTableTest, DupFd)
	TEST_F (FdTableTest, SetupStandardFiles)
	TEST_F (VfsTest, LookupRoot)
	TEST_F (VfsTest, LookupInvalidPaths)
	TEST_F (VfsInitTest, DoubleInit)
	TEST (FileStructTest, FileOperations)
	TEST (InodeStructTest, InodeDefaults)
	TEST (DentryStructTest, DentryDefaults)
	TEST (OpenFlagsTest, FlagValues)
	TEST (SeekWhenceTest, EnumValues)

Function Documentation

TEST() [1/5]

TEST	(	DentryStructTest	,
		DentryDefaults
	)

Definition at line 301 of file vfs_test.cpp.

                                       {
  Dentry dentry;
  EXPECT_EQ(dentry.name[0], '\0');
  EXPECT_EQ(dentry.inode, nullptr);
  EXPECT_EQ(dentry.parent, nullptr);
  EXPECT_EQ(dentry.children, nullptr);
  EXPECT_EQ(dentry.next_sibling, nullptr);
  EXPECT_EQ(dentry.fs_private, nullptr);
}

TEST() [2/5]

TEST	(	FileStructTest	,
		FileOperations
	)

Definition at line 278 of file vfs_test.cpp.

                                     {
  File file;
  EXPECT_EQ(file.offset, 0);
  EXPECT_EQ(file.flags, 0);
  EXPECT_EQ(file.ops, nullptr);
  EXPECT_EQ(file.inode, nullptr);
  EXPECT_EQ(file.dentry, nullptr);
}

TEST() [3/5]

TEST	(	InodeStructTest	,
		InodeDefaults
	)

Definition at line 288 of file vfs_test.cpp.

                                     {
  Inode inode;
  EXPECT_EQ(inode.ino, 0);
  EXPECT_EQ(inode.type, FileType::kUnknown);
  EXPECT_EQ(inode.size, 0);
  EXPECT_EQ(inode.permissions, 0644);
  EXPECT_EQ(inode.link_count, 1);
  EXPECT_EQ(inode.fs_private, nullptr);
  EXPECT_EQ(inode.fs, nullptr);
  EXPECT_EQ(inode.ops, nullptr);
}

TEST() [4/5]

TEST	(	OpenFlagsTest	,
		FlagValues
	)

Definition at line 312 of file vfs_test.cpp.

                                {
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOReadOnly), 0x0000u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOWriteOnly), 0x0001u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOReadWrite), 0x0002u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOCreate), 0x0040u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOTruncate), 0x0200u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kOAppend), 0x0400u);
  EXPECT_EQ(static_cast<uint32_t>(OpenFlags::kODirectory), 0x010000u);
}

TEST() [5/5]

TEST	(	SeekWhenceTest	,
		EnumValues
	)

Definition at line 323 of file vfs_test.cpp.

                                 {
  EXPECT_EQ(static_cast<int>(SeekWhence::kSet), 0);
  EXPECT_EQ(static_cast<int>(SeekWhence::kCur), 1);
  EXPECT_EQ(static_cast<int>(SeekWhence::kEnd), 2);
}

TEST_F() [1/9]

TEST_F	(	FdTableTest	,
		AllocAndFree
	)

Definition at line 168 of file vfs_test.cpp.

                                  {
  // 创建模拟文件
  File mock_file;
 
  // 分配 fd
  auto alloc_result = fd_table_->Alloc(&mock_file);
  EXPECT_TRUE(alloc_result.has_value());
  int fd = alloc_result.value();
  EXPECT_GE(fd, 3);  // 0/1/2 预留给标准流
 
  // 获取文件
  File* file = fd_table_->Get(fd);
  EXPECT_EQ(file, &mock_file);
 
  // 释放 fd
  auto free_result = fd_table_->Free(fd);
  EXPECT_TRUE(free_result.has_value());
 
  // 再次获取应该返回 nullptr
  file = fd_table_->Get(fd);
  EXPECT_EQ(file, nullptr);
}

TEST_F() [2/9]

TEST_F	(	FdTableTest	,
		DupFd
	)

Definition at line 204 of file vfs_test.cpp.

                           {
  File mock_file;
 
  // 分配 fd
  auto alloc_result = fd_table_->Alloc(&mock_file);
  EXPECT_TRUE(alloc_result.has_value());
  int fd1 = alloc_result.value();
 
  // 复制 fd
  auto dup_result = fd_table_->Dup(fd1);
  EXPECT_TRUE(dup_result.has_value());
  int fd2 = dup_result.value();
 
  // fd1 和 fd2 应该指向同一个文件
  EXPECT_EQ(fd_table_->Get(fd1), fd_table_->Get(fd2));
 
  // 清理
  (void)fd_table_->Free(fd1);
  (void)fd_table_->Free(fd2);
}

TEST_F() [3/9]

TEST_F	(	FdTableTest	,
		InvalidFd
	)

Definition at line 191 of file vfs_test.cpp.

                               {
  // 无效 fd
  File* file = fd_table_->Get(-1);
  EXPECT_EQ(file, nullptr);
 
  file = fd_table_->Get(999);
  EXPECT_EQ(file, nullptr);
 
  // 释放无效 fd
  auto free_result = fd_table_->Free(-1);
  EXPECT_FALSE(free_result.has_value());
}

TEST_F() [4/9]

TEST_F	(	FdTableTest	,
		SetupStandardFiles
	)

Definition at line 225 of file vfs_test.cpp.

                                        {
  File stdin_file;
  File stdout_file;
  File stderr_file;
 
  auto setup_result =
      fd_table_->SetupStandardFiles(&stdin_file, &stdout_file, &stderr_file);
  EXPECT_TRUE(setup_result.has_value());
 
  // 检查标准文件描述符
  EXPECT_EQ(fd_table_->Get(0), &stdin_file);
  EXPECT_EQ(fd_table_->Get(1), &stdout_file);
  EXPECT_EQ(fd_table_->Get(2), &stderr_file);
}

TEST_F() [5/9]

TEST_F	(	MountTableTest	,
		LookupMountPoint
	)

Definition at line 135 of file vfs_test.cpp.

                                         {
  MountTable mount_table;
  MockFs mock_fs;
 
  auto mount_result = mount_table.Mount("/", &mock_fs, nullptr);
  EXPECT_TRUE(mount_result.has_value());
 
  // 查找根挂载点
  auto* mp = mount_table.Lookup("/file.txt");
  EXPECT_NE(mp, nullptr);
 
  // 查找不存在挂载的路径
  mp = mount_table.Lookup("/mnt/nonexistent/file");
  EXPECT_NE(mp, nullptr);  // 应该返回根挂载点
  (void)mount_table.Unmount("/");
}

Here is the call graph for this function:

TEST_F() [6/9]

TEST_F	(	MountTableTest	,
		MountAndUnmount
	)

Definition at line 111 of file vfs_test.cpp.

                                        {
  MountTable mount_table;
  MockFs mock_fs;
 
  // 测试挂载
  auto mount_result = mount_table.Mount("/", &mock_fs, nullptr);
  EXPECT_TRUE(mount_result.has_value());
  EXPECT_TRUE(mock_fs.mount_called);
 
  // 测试重复挂载
  mount_result = mount_table.Mount("/", &mock_fs, nullptr);
  EXPECT_FALSE(mount_result.has_value());
 
  // 测试卸载
  auto unmount_result = mount_table.Unmount("/");
  (void)unmount_result;
  EXPECT_TRUE(unmount_result.has_value());
  EXPECT_TRUE(mock_fs.unmount_called);
 
  // 测试卸载未挂载的路径
  unmount_result = mount_table.Unmount("/mnt");
  EXPECT_FALSE(unmount_result.has_value());
}

Here is the call graph for this function:

TEST_F() [7/9]

TEST_F	(	VfsInitTest	,
		DoubleInit
	)

Definition at line 267 of file vfs_test.cpp.

                                {
  // 第一次初始化
  auto result = vfs::Init();
  EXPECT_TRUE(result.has_value());
 
  // 重复初始化应该成功（幂等）
  result = vfs::Init();
  EXPECT_TRUE(result.has_value());
}

Here is the call graph for this function:

TEST_F() [8/9]

TEST_F	(	VfsTest	,
		LookupInvalidPaths
	)

Definition at line 255 of file vfs_test.cpp.

                                    {
  // 空路径
  auto result = vfs::Lookup(nullptr);
  EXPECT_FALSE(result.has_value());
 
  // 相对路径
  result = vfs::Lookup("relative/path");
  EXPECT_FALSE(result.has_value());
}

Here is the call graph for this function:

TEST_F() [9/9]

TEST_F	(	VfsTest	,
		LookupRoot
	)

Definition at line 241 of file vfs_test.cpp.

                            {
  // 挂载 mock 文件系统作为根
  MockFs mock_fs;
  auto& mount_table = GetMountTable();
 
  auto mount_result = mount_table.Mount("/", &mock_fs, nullptr);
  EXPECT_TRUE(mount_result.has_value());
 
  // 查找根目录
  auto lookup_result = vfs::Lookup("/");
  EXPECT_TRUE(lookup_result.has_value());
  EXPECT_NE(lookup_result.value(), nullptr);
}

Here is the call graph for this function: