text: #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <limits.h>
  #include <stdlib.h>
  #include <errno.h>
  #include "test_fs.h"
  
  // ============================================================================
  // Helper variable and function
  // ============================================================================
  
  static ssize_t get_path_by_fd(int fd, char *buf, ssize_t buf_len) {
      char proc_fd[64] = { 0 };
      int n;
  
      n = snprintf(proc_fd, sizeof(proc_fd), "/proc/self/fd/%d", fd);
      if (n < 0) {
          THROW_ERROR("failed to call snprintf for %d", fd);
      }
  
      return readlink(proc_fd, buf, buf_len);
  }
  
  static int create_file(const char *file_path) {
      int fd;
      int flags = O_RDONLY | O_CREAT | O_TRUNC;
      int mode = 00666;
  
      fd = open(file_path, flags, mode);
      if (fd < 0) {
          THROW_ERROR("failed to create a file");
      }
      close(fd);
  
      return 0;
  }
  
  static int remove_file(const char *file_path) {
      int ret;
  
      ret = unlink(file_path);
      if (ret < 0) {
          THROW_ERROR("failed to unlink the created file");
      }
  
      return 0;
  }
  
  // ============================================================================
  // Test cases for readlink
  // ============================================================================
  
  static int __test_readlink_from_proc_self_fd(const char *file_path) {
      char buf[128] = { 0 };
      int fd;
      ssize_t n;
  
      fd = open(file_path, O_RDONLY);
      if (fd < 0) {
          THROW_ERROR("failed to open `%s` for read", file_path);
      }
      n = get_path_by_fd(fd, buf, sizeof(buf));
      close(fd);
      if (n < 0) {
          THROW_ERROR("failed to readlink for `%s`", file_path);
      }
      if (n != strlen(file_path)) {
          THROW_ERROR("readlink for `%s` length is wrong", file_path);
      }
      if (strncmp(buf, file_path, n) != 0) {
          THROW_ERROR("check the path for `%s` failed", file_path);
      }
  
      return 0;
  }
  
  static int __test_realpath(const char *file_path) {
      char buf[PATH_MAX] = { 0 };
      char dir_buf[PATH_MAX] = { 0 };
      char base_buf[PATH_MAX] = { 0 };
      char *dir_name, *file_name, *res;
  
      if (fs_split_path(file_path, dir_buf, &dir_name, base_buf, &file_name) < 0) {
          THROW_ERROR("failed to split path");
      }
      if (chdir(dir_name) < 0) {
          THROW_ERROR("failed to chdir to %s", dir_name);
      }
      res = realpath(file_name, buf);
      if (res == NULL) {
          THROW_ERROR("failed to get the realpath for `%s`", file_name);
      }
      if (strlen(buf) != strlen(file_path)) {
          THROW_ERROR("realpath for '%s' length is wrong", file_name);
      }
      if (strncmp(buf, file_path, strlen(buf)) != 0) {
          THROW_ERROR("check the realpath for '%s' failed", file_name);
      }
      if (chdir("/") < 0) {
          THROW_ERROR("failed to chdir to '/'");
      }
  
      return 0;
  }
  
  static int __test_readlinkat(const char *file_path) {
      int dirfd;
      size_t n;
      char buf[128] = { 0 };
  #define LINK_DIR "/root"
  #define LINK_NAME "test_symlink.link"
      const char *link_path = LINK_DIR"/"LINK_NAME;
      if (symlink(file_path, link_path) < 0) {
          THROW_ERROR("failed to create symlink");
      }
  
      dirfd = open(LINK_DIR, O_RDONLY);
      if (dirfd < 0) {
          THROW_ERROR("failed to open dir");
      }
      n = readlinkat(dirfd, LINK_NAME, buf, sizeof(buf));
      if (n < 0) {
          THROW_ERROR("failed to readlinkat from %s", link_path);
      } else if (n != strlen(file_path)) {
          THROW_ERROR("readlink from %s length is wrong", link_path);
      }
      if (strncmp(buf, file_path, n) != 0) {
          THROW_ERROR("check the content from %s failed", link_path);
      }
      close(dirfd);
      if (remove_file(link_path) < 0) {
          THROW_ERROR("failed to delete link file");
      }
      return 0;
  }
  
  typedef int(*test_readlink_func_t)(const char *);
  
  static int test_readlink_framework(test_readlink_func_t fn) {
      const char *file_path = "/root/test_filesystem_symlink.txt";
  
      if (create_file(file_path) < 0) {
          return -1;
      }
      if (fn(file_path) < 0) {
          return -1;
      }
      if (remove_file(file_path) < 0) {
          return -1;
      }
  
      return 0;
  }
  
  static int test_readlink_from_proc_self_fd() {
      return test_readlink_framework(__test_readlink_from_proc_self_fd);
  }
  
  static int test_realpath() {
      return test_readlink_framework(__test_realpath);
  }
  
  static int test_readlinkat() {
      return test_readlink_framework(__test_readlinkat);
  }
  
  // ============================================================================
  // Test cases for symlink
  // ============================================================================
  
  static int __test_symlinkat(const char *target, const char *link_path) {
      char dir_buf[PATH_MAX] = { 0 };
      char base_buf[PATH_MAX] = { 0 };
      char *dir_name, *link_name;
  
      if (create_file(target) < 0) {
          THROW_ERROR("failed to create target file");
      }
      int fd = open(target, O_WRONLY);
      if (fd < 0) {
          THROW_ERROR("failed to open target to write");
      }
      char *write_str = "Hello World\n";
      if (write(fd, write_str, strlen(write_str)) <= 0) {
          THROW_ERROR("failed to write");
      }
      close(fd);
  
      if (fs_split_path(link_path, dir_buf, &dir_name, base_buf, &link_name) < 0) {
          THROW_ERROR("failed to split path");
      }
      int dirfd = open(dir_name, O_RDONLY);
      if (dirfd < 0) {
          THROW_ERROR("failed to open dir");
      }
      if (symlinkat(target, dirfd, link_name) < 0) {
          THROW_ERROR("failed to create symlink");
      }
      close(dirfd);
  
      if (chdir(dir_name) < 0) {
          THROW_ERROR("failed to chdir to %s", dir_name);
      }
      fd = open(link_name, O_RDONLY);
      if (fd < 0) {
          THROW_ERROR("failed to open link file to read");
      }
      char read_buf[128] = { 0 };
      if (read(fd, read_buf, sizeof(read_buf)) != strlen(write_str)) {
          THROW_ERROR("failed to read");
      }
      if (strcmp(write_str, read_buf) != 0) {
          THROW_ERROR("the message read from the file is not as it was written");
      }
      close(fd);
  
      if (remove_file(target) < 0) {
          THROW_ERROR("failed to delete target file");
      }
      if (chdir("/") < 0) {
          THROW_ERROR("failed to chdir back");
      }
      return 0;
  }
  
  
  static int __test_symlink(const char *target, const char *link_path) {
      char dir_buf[PATH_MAX] = { 0 };
      char *dir_name;
      char target_path[PATH_MAX * 2] = { 0 };
  
      if (target[0] == '/') {
          snprintf(target_path, sizeof(target_path), "%s", target);
      } else {
          // If `target` is not an absolute path,
          // it must be a path relative to the directory of the `link_path`
          if (fs_split_path(link_path, dir_buf, &dir_name, NULL, NULL) < 0) {
              THROW_ERROR("failed to split path");
          }
          snprintf(target_path, sizeof(target_path), "%s/%s", dir_name, target);
      }
      if (create_file(target_path) < 0) {
          THROW_ERROR("failed to create target file");
      }
  
      int fd = open(target_path, O_WRONLY);
      if (fd < 0) {
          THROW_ERROR("failed to open target to write");
      }
      char *write_str = "Hello World\n";
      if (write(fd, write_str, strlen(write_str)) <= 0) {
          THROW_ERROR("failed to write");
      }
      close(fd);
  
      if (symlink(target, link_path) < 0) {
          THROW_ERROR("failed to create symlink");
      }
  
      fd = open(link_path, O_RDONLY | O_NOFOLLOW);
      if (fd >= 0 || errno != ELOOP) {
          THROW_ERROR("failed to check open file with O_NOFOLLOW flags");
      }
  
      fd = open(link_path, O_RDONLY);
      if (fd < 0) {
          THROW_ERROR("failed to open link file to read");
      }
      char read_buf[128] = { 0 };
      if (read(fd, read_buf, sizeof(read_buf)) != strlen(write_str)) {
          THROW_ERROR("failed to read");
      }
      if (strcmp(write_str, read_buf) != 0) {
          THROW_ERROR("the message read from the file is not as it was written");
      }
      close(fd);
  
      char readlink_buf[256] = { 0 };
      if (readlink(link_path, readlink_buf, sizeof(readlink_buf)) < 0) {
          THROW_ERROR("readlink failed");
      }
      if (strcmp(target, readlink_buf) != 0) {
          THROW_ERROR("check readlink result failed");
      }
  
      if (remove_file(target_path) < 0) {
          THROW_ERROR("failed to delete target file");
      }
  
      return 0;
  }
  
  static int __test_create_file_from_symlink(const char *target, const char *link_path) {
      char dir_buf[PATH_MAX] = { 0 };
      char *dir_name;
      char target_path[PATH_MAX * 2] = { 0 };
  
      if (target[0] == '/') {
          snprintf(target_path, sizeof(target_path), "%s", target);
      } else {
          // If `target` is not an absolute path,
          // it must be a path relative to the directory of the `link_path`
          if (fs_split_path(link_path, dir_buf, &dir_name, NULL, NULL) < 0) {
              THROW_ERROR("failed to split path");
          }
          snprintf(target_path, sizeof(target_path), "%s/%s", dir_name, target);
      }
  
      if (symlink(target, link_path) < 0) {
          THROW_ERROR("failed to create symlink");
      }
  
      int fd = open(link_path, O_RDONLY, 00666);
      if (fd >= 0 || errno != ENOENT) {
          THROW_ERROR("failed to check open a dangling symbolic link");
      }
  
      if (create_file(link_path) < 0) {
          THROW_ERROR("failed to create link file");
      }
      struct stat stat_buf;
      if (stat(target_path, &stat_buf) < 0) {
          THROW_ERROR("failed to stat the target file");
      }
  
      if (remove_file(target_path) < 0) {
          THROW_ERROR("failed to delete target file");
      }
  
      return 0;
  }
  
  typedef int(*test_symlink_func_t)(const char *, const char *);
  
  static int test_symlink_framework(test_symlink_func_t fn, const char *target,
                                    const char *link) {
      if (fn(target, link) < 0) {
          return -1;
      }
      if (remove_file(link) < 0) {
          return -1;
      }
  
      return 0;
  }
  
  static int test_symlinkat() {
      char *target = "/root/test_symlink.file";
      char *link = "/root/test_symlink.link";
      return test_symlink_framework(__test_symlinkat, target, link);
  }
  
  static int test_symlinkat_ramfs() {
      char *target = "/root/test_symlink.file";
      char *link = "/dev/shm/test_symlink.link";
      return test_symlink_framework(__test_symlinkat, target, link);
  }
  
  static int test_symlink_to_absolute_target() {
      char *target = "/root/test_symlink.file";
      char *link = "/root/test_symlink.link";
      return test_symlink_framework(__test_symlink, target, link);
  }
  
  static int test_symlink_to_relative_target() {
      char *target = "./test_symlink.file";
      char *link = "/root/test_symlink.link";
      if (test_symlink_framework(__test_symlink, target, link) < 0) {
          return -1;
      }
      target = "../root/test_symlink.file";
      if (test_symlink_framework(__test_symlink, target, link) < 0) {
          return -1;
      }
      return 0;
  }
  
  static int test_symlink_from_ramfs() {
      char *target = "/root/test_symlink.file";
      char *link = "/dev/shm/test_symlink.link";
      return test_symlink_framework(__test_symlink, target, link);
  }
  
  static int test_symlink_to_ramfs() {
      char *target = "/dev/shm/test_symlink.file";
      char *link = "/root/test_symlink.link";
      return test_symlink_framework(__test_symlink, target, link);
  }
  
  static int test_symlink_with_empty_target_or_link_path() {
      char *target = "/root/test_symlink.file";
      char *link_path = "/root/test_symlink.link";
  
      int ret = symlink("", link_path);
      if (ret >= 0 || errno != ENOENT) {
          THROW_ERROR("failed to check symlink with empty target");
      }
      ret = symlink(target, "");
      if (ret >= 0 || errno != ENOENT) {
          THROW_ERROR("failed to check symlink with empty linkpath");
      }
      return 0;
  }
  
  static int test_create_file_from_symlink_to_absolute_target() {
      char *target = "/root/test_symlink.file";
      char *link = "/root/test_symlink.link";
      return test_symlink_framework(__test_create_file_from_symlink, target, link);
  }
  
  static int test_create_file_from_symlink_to_relative_target() {
      char *target = "test_symlink.file";
      char *link = "/root/test_symlink.link";
      if (test_symlink_framework(__test_create_file_from_symlink, target, link) < 0) {
          return -1;
      }
      target = "../root/test_symlink.file";
      if (test_symlink_framework(__test_create_file_from_symlink, target, link) < 0) {
          return -1;
      }
      return 0;
  }
  
  // ============================================================================
  // Test suite main
  // ============================================================================
  
  static test_case_t test_cases[] = {
      TEST_CASE(test_readlink_from_proc_self_fd),
      TEST_CASE(test_realpath),
      TEST_CASE(test_readlinkat),
      TEST_CASE(test_symlinkat),
      TEST_CASE(test_symlinkat_ramfs),
      TEST_CASE(test_symlink_to_absolute_target),
      TEST_CASE(test_symlink_to_relative_target),
      TEST_CASE(test_symlink_from_ramfs),
      TEST_CASE(test_symlink_to_ramfs),
      TEST_CASE(test_symlink_with_empty_target_or_link_path),
      TEST_CASE(test_create_file_from_symlink_to_absolute_target),
      TEST_CASE(test_create_file_from_symlink_to_relative_target),
  };
  
  int main(int argc, const char *argv[]) {
      return test_suite_run(test_cases, ARRAY_SIZE(test_cases));
  }
  