test_io_utils.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "tests.h"
#include "io_utils.h"
#include "utils_core.h"
 
static void utest_file_exists(char const * tmp_base_path);
static void utest_file_contains(char const * tmp_base_path);
static void utest_file_path_join(void);
static void utest_remove_directory(char const * tmp_base_path);
 
int main(int argc, char ** argv) {
 
  if (argc != 2) {
    PUT_ERR("wrong number of arguments\n");
    return TEST_EXIT_CODE;
  }
 
  utest_file_exists(argv[1]);
  utest_file_contains(argv[1]);
  utest_file_path_join();
  utest_remove_directory(argv[1]);
 
  return TEST_EXIT_CODE;
}
 
static char * utest_make_tmp_path(
  char const * tmp_base_path, char const * name_prefix) {
 
  // "XXXXXX" is a template for mkstemp/mkdtemp to create a unique
  // temporary file/directory
  return yac_file_path_join(tmp_base_path, name_prefix, "XXXXXX");
}
 
static char * utest_make_tmp_dir(
  char const * tmp_base_path, char const * name_prefix) {
 
  char * path = utest_make_tmp_path(tmp_base_path, name_prefix);
 
  path = mkdtemp(path);
 
  YAC_ASSERT_F(
    path != NULL, "mkdtemp failed for tmp_base_path=\"%s\", name_prefix=\"%s\"",
    tmp_base_path, name_prefix);
 
  return path;
}
 
static char * utest_write_tmp_file(
  char const * tmp_base_path, char const * content) {
 
  char * path = utest_make_tmp_path(tmp_base_path, "test_io_utils_");
 
  YAC_ASSERT_F(path != NULL, "failed to create temporary path");
 
  int fd = mkstemp(path);
 
  YAC_ASSERT_F(fd != -1, "mkstemp failed for path \"%s\"", path);
 
  size_t len = strlen(content);
 
  int status = write(fd, content, len);
  YAC_ASSERT_F(status == (int)len, "short write for path \"%s\"", path);
 
  close(fd);
 
  return path;
}
 
static void utest_file_exists(char const * tmp_base_path) {
 
  { // test non-existent file
 
    // create a temporary file and then remove it to ensure it does not exist
    char * path = utest_make_tmp_path(tmp_base_path, "no_such_file_");
 
    {
      int fd = mkstemp(path);
      YAC_ASSERT(fd != -1, "mkstemp failed");
      close(fd);
      unlink(path);
    }
 
    if (yac_file_exists(path))
      PUT_ERR("yac_file_exists: expected 0 for non-existent file\n");
 
    free(path);
  }
 
  { // test existing file
    char * path = utest_write_tmp_file(tmp_base_path, "hello\n");
 
    if (!yac_file_exists(path))
      PUT_ERR("yac_file_exists: expected 1 for existing file\n");
 
    unlink(path);
    free(path);
  }
}
 
static void utest_file_contains(char const * tmp_base_path) {
 
  { // test file containing the needle
    char * path = utest_write_tmp_file(
      tmp_base_path, "first line\nneedle_token here\nlast line\n");
 
    if (!yac_file_contains(path, "needle_token"))
      PUT_ERR("yac_file_contains: expected 1 when needle is present\n");
 
    unlink(path);
    free(path);
  }
 
  { // test file not containing the needle
    char * path = utest_write_tmp_file(
      tmp_base_path, "first line\nsecond line\nthird line\n");
 
    if (yac_file_contains(path, "needle_token"))
      PUT_ERR("yac_file_contains: expected 0 when needle is absent\n");
 
    unlink(path);
    free(path);
  }
}
 
static void utest_file_path_join(void) {
 
  { // test joining two simple path components
    char * path = yac_file_path_join("base", "file.txt", NULL);
 
    if (strcmp(path, "base/file.txt"))
      PUT_ERR(
        "yac_file_path_join: unexpected join result for base and file.txt\n");
 
    free(path);
  }
 
  { // test joining a path with a leading slash and a file name
    char * path = yac_file_path_join("/tmp", "abc", NULL);
 
    if (strcmp(path, "/tmp/abc"))
      PUT_ERR("yac_file_path_join: unexpected join result for /tmp and abc\n");
 
    free(path);
  }
 
  { // test joining a path with a trailing slash and a file name
    char * path = yac_file_path_join("root/", "child", NULL);
 
    if (strcmp(path, "root//child"))
      PUT_ERR(
        "yac_file_path_join: unexpected join result for root/ and child\n");
 
    free(path);
  }
 
  { // test joining path components with extension
    char * path = yac_file_path_join("base", "file", ".txt");
 
    if (strcmp(path, "base/file.txt"))
      PUT_ERR(
        "yac_file_path_join: unexpected join result for base, file, .txt\n");
 
    free(path);
  }
 
  { // test joining path components with empty extension
    char * path = yac_file_path_join("base", "file", "");
 
    if (strcmp(path, "base/file"))
      PUT_ERR(
        "yac_file_path_join: unexpected join result for base, file, \"\"\n");
 
    free(path);
  }
}
 
static void utest_remove_directory(char const * tmp_base_path) {
 
  { // test empty directory
 
    // create a temporary directory
    char * dir = utest_make_tmp_dir(tmp_base_path, "test_io_utils_dir_");
 
    yac_remove_directory(dir);
 
    if (yac_file_exists(dir))
      PUT_ERR(
        "yac_remove_directory: empty dir still exists after removal\n");
 
    free(dir);
  }
 
  { // test directory with a file
    char * dir = utest_make_tmp_dir(tmp_base_path, "test_io_utils_dir_");
    char * file_path = utest_write_tmp_file(dir, "content\n");
 
    yac_remove_directory(dir);
 
    if (yac_file_exists(dir))
      PUT_ERR(
        "yac_remove_directory: empty dir still exists after removal\n");
 
    free(dir);
    free(file_path);
  }
 
  { // test directory with a subdirectory and a file
    char * dir = utest_make_tmp_dir(tmp_base_path, "test_io_utils_dir_");
    char * subdir_path = utest_make_tmp_dir(dir, "subdir_");
    char * file_path = utest_write_tmp_file(subdir_path, "nested content\n");
 
    yac_remove_directory(dir);
 
    if (yac_file_exists(dir))
      PUT_ERR(
        "yac_remove_directory: dir with subdir still exists after removal\n");
 
    free(dir);
    free(subdir_path);
    free(file_path);
  }
 
  { // test more complex directory structure with multiple levels of
    // subdirectories and files:
    // dir/
    // ├── subdir1/
    // │   ├── file1.txt
    // │   └── subsubdir1/
    // │       └── file2.txt
    // └── subdir2/
    //     ├── file3.txt
    //     └── file4.txt
    char * dir = utest_make_tmp_dir(tmp_base_path, "test_io_utils_dir_");
    char * subdir1 = utest_make_tmp_dir(dir, "subdir1_");
    char * file1 = utest_write_tmp_file(subdir1, "file1 content\n");
    char * subsubdir1 = utest_make_tmp_dir(subdir1, "subsubdir1_");
    char * file2 = utest_write_tmp_file(subsubdir1, "file2 content\n");
    char * subdir2 = utest_make_tmp_dir(dir, "subdir2_");
    char * file3 = utest_write_tmp_file(subdir2, "file3 content\n");
    char * file4 = utest_write_tmp_file(subdir2, "file4 content\n");
 
    yac_remove_directory(dir);
 
    if (yac_file_exists(dir))
      PUT_ERR(
        "yac_remove_directory: complex dir structure still exists after removal\n");
 
    free(dir);
    free(subdir1);
    free(file1);
    free(subsubdir1);
    free(file2);
    free(subdir2);
    free(file3);
    free(file4);
  }
}