thodg/libgit2/tests/core/dirent.c

• Show log

  Commit

• Hash : e54343a4
  Author :
  Date : 2019-06-29T09:17:32
  

  fileops: rename to "futils.h" to match function signatures Our file utils functions all have a "futils" prefix, e.g. `git_futils_touch`. One would thus naturally guess that their definitions and implementation would live in files "futils.h" and "futils.c", respectively, but in fact they live in "fileops.h". Rename the files to match expectations.

Download

• tests/core/dirent.c

• #include "clar_libgit2.h"
  #include "futils.h"
  
  typedef struct name_data {
  	int count; /* return count */
  	char *name; /* filename		*/
  } name_data;
  
  typedef struct walk_data {
  	char *sub;		/* sub-directory name */
  	name_data *names; /* name state data	*/
  	git_buf path;
  } walk_data;
  
  
  static char *top_dir = "dir-walk";
  static walk_data *state_loc;
  
  static void setup(walk_data *d)
  {
  	name_data *n;
  
  	cl_must_pass(p_mkdir(top_dir, 0777));
  
  	cl_must_pass(p_chdir(top_dir));
  
  	if (strcmp(d->sub, ".") != 0)
  		cl_must_pass(p_mkdir(d->sub, 0777));
  
  	cl_git_pass(git_buf_sets(&d->path, d->sub));
  
  	state_loc = d;
  
  	for (n = d->names; n->name; n++) {
  		git_file fd = p_creat(n->name, 0666);
  		cl_assert(fd >= 0);
  		p_close(fd);
  		n->count = 0;
  	}
  }
  
  static void dirent_cleanup__cb(void *_d)
  {
  	walk_data *d = _d;
  	name_data *n;
  
  	for (n = d->names; n->name; n++) {
  		cl_must_pass(p_unlink(n->name));
  	}
  
  	if (strcmp(d->sub, ".") != 0)
  		cl_must_pass(p_rmdir(d->sub));
  
  	cl_must_pass(p_chdir(".."));
  
  	cl_must_pass(p_rmdir(top_dir));
  
  	git_buf_dispose(&d->path);
  }
  
  static void check_counts(walk_data *d)
  {
  	name_data *n;
  
  	for (n = d->names; n->name; n++) {
  		cl_assert(n->count == 1);
  	}
  }
  
  static int update_count(name_data *data, const char *name)
  {
  	name_data *n;
  
  	for (n = data; n->name; n++) {
  		if (!strcmp(n->name, name)) {
  			n->count++;
  			return 0;
  		}
  	}
  
  	return GIT_ERROR;
  }
  
  static int one_entry(void *state, git_buf *path)
  {
  	walk_data *d = (walk_data *) state;
  
  	if (state != state_loc)
  		return GIT_ERROR;
  
  	if (path != &d->path)
  		return GIT_ERROR;
  
  	return update_count(d->names, path->ptr);
  }
  
  
  static name_data dot_names[] = {
  	{ 0, "./a" },
  	{ 0, "./asdf" },
  	{ 0, "./pack-foo.pack" },
  	{ 0, NULL }
  };
  static walk_data dot = {
  	".",
  	dot_names,
  	GIT_BUF_INIT
  };
  
  /* make sure that the '.' folder is not traversed */
  void test_core_dirent__dont_traverse_dot(void)
  {
  	cl_set_cleanup(&dirent_cleanup__cb, &dot);
  	setup(&dot);
  
  	cl_git_pass(git_path_direach(&dot.path, 0, one_entry, &dot));
  
  	check_counts(&dot);
  }
  
  
  static name_data sub_names[] = {
  	{ 0, "sub/a" },
  	{ 0, "sub/asdf" },
  	{ 0, "sub/pack-foo.pack" },
  	{ 0, NULL }
  };
  static walk_data sub = {
  	"sub",
  	sub_names,
  	GIT_BUF_INIT
  };
  
  /* traverse a subfolder */
  void test_core_dirent__traverse_subfolder(void)
  {
  	cl_set_cleanup(&dirent_cleanup__cb, &sub);
  	setup(&sub);
  
  	cl_git_pass(git_path_direach(&sub.path, 0, one_entry, &sub));
  
  	check_counts(&sub);
  }
  
  
  static walk_data sub_slash = {
  	"sub/",
  	sub_names,
  	GIT_BUF_INIT
  };
  
  /* traverse a slash-terminated subfolder */
  void test_core_dirent__traverse_slash_terminated_folder(void)
  {
  	cl_set_cleanup(&dirent_cleanup__cb, &sub_slash);
  	setup(&sub_slash);
  
  	cl_git_pass(git_path_direach(&sub_slash.path, 0, one_entry, &sub_slash));
  
  	check_counts(&sub_slash);
  }
  
  
  static name_data empty_names[] = {
  	{ 0, NULL }
  };
  static walk_data empty = {
  	"empty",
  	empty_names,
  	GIT_BUF_INIT
  };
  
  /* make sure that empty folders are not traversed */
  void test_core_dirent__dont_traverse_empty_folders(void)
  {
  	cl_set_cleanup(&dirent_cleanup__cb, &empty);
  	setup(&empty);
  
  	cl_git_pass(git_path_direach(&empty.path, 0, one_entry, &empty));
  
  	check_counts(&empty);
  
  	/* make sure callback not called */
  	cl_assert(git_path_is_empty_dir(empty.path.ptr));
  }
  
  static name_data odd_names[] = {
  	{ 0, "odd/.a" },
  	{ 0, "odd/..c" },
  	/* the following don't work on cygwin/win32 */
  	/* { 0, "odd/.b." }, */
  	/* { 0, "odd/..d.." }, */
  	{ 0, NULL }
  };
  static walk_data odd = {
  	"odd",
  	odd_names,
  	GIT_BUF_INIT
  };
  
  /* make sure that strange looking filenames ('..c') are traversed */
  void test_core_dirent__traverse_weird_filenames(void)
  {
  	cl_set_cleanup(&dirent_cleanup__cb, &odd);
  	setup(&odd);
  
  	cl_git_pass(git_path_direach(&odd.path, 0, one_entry, &odd));
  
  	check_counts(&odd);
  }
  
  /* test filename length limits */
  void test_core_dirent__length_limits(void)
  {
  	char *big_filename = (char *)git__malloc(FILENAME_MAX + 1);
  	memset(big_filename, 'a', FILENAME_MAX + 1);
  	big_filename[FILENAME_MAX] = 0;
  
  	cl_must_fail(p_creat(big_filename, 0666));
  
  	git__free(big_filename);
  }
  
  void test_core_dirent__empty_dir(void)
  {
  	cl_must_pass(p_mkdir("empty_dir", 0777));
  	cl_assert(git_path_is_empty_dir("empty_dir"));
  
  	cl_git_mkfile("empty_dir/content", "whatever\n");
  	cl_assert(!git_path_is_empty_dir("empty_dir"));
  	cl_assert(!git_path_is_empty_dir("empty_dir/content"));
  
  	cl_must_pass(p_unlink("empty_dir/content"));
  
  	cl_must_pass(p_mkdir("empty_dir/content", 0777));
  	cl_assert(!git_path_is_empty_dir("empty_dir"));
  	cl_assert(git_path_is_empty_dir("empty_dir/content"));
  
  	cl_must_pass(p_rmdir("empty_dir/content"));
  
  	cl_must_pass(p_rmdir("empty_dir"));
  }
  
  static void handle_next(git_path_diriter *diriter, walk_data *walk)
  {
  	const char *fullpath, *filename;
  	size_t fullpath_len, filename_len;
  
  	cl_git_pass(git_path_diriter_fullpath(&fullpath, &fullpath_len, diriter));
  	cl_git_pass(git_path_diriter_filename(&filename, &filename_len, diriter));
  
  	cl_assert_equal_strn(fullpath, "sub/", 4);
  	cl_assert_equal_s(fullpath+4, filename);
  
  	update_count(walk->names, fullpath);
  }
  
  /* test directory iterator */
  void test_core_dirent__diriter_with_fullname(void)
  {
  	git_path_diriter diriter = GIT_PATH_DIRITER_INIT;
  	int error;
  
  	cl_set_cleanup(&dirent_cleanup__cb, &sub);
  	setup(&sub);
  
  	cl_git_pass(git_path_diriter_init(&diriter, sub.path.ptr, 0));
  
  	while ((error = git_path_diriter_next(&diriter)) == 0)
  		handle_next(&diriter, &sub);
  
  	cl_assert_equal_i(error, GIT_ITEROVER);
  
  	git_path_diriter_free(&diriter);
  
  	check_counts(&sub);
  }
  
  void test_core_dirent__diriter_at_directory_root(void)
  {
  	git_path_diriter diriter = GIT_PATH_DIRITER_INIT;
  	const char *sandbox_path, *path;
  	char *root_path;
  	size_t path_len;
  	int root_offset, error;
  
  	sandbox_path = clar_sandbox_path();
  	cl_assert((root_offset = git_path_root(sandbox_path)) >= 0);
  
  	cl_assert(root_path = git__calloc(1, root_offset + 2));
  	strncpy(root_path, sandbox_path, root_offset + 1);
  
  	cl_git_pass(git_path_diriter_init(&diriter, root_path, 0));
  
  	while ((error = git_path_diriter_next(&diriter)) == 0) {
  		cl_git_pass(git_path_diriter_fullpath(&path, &path_len, &diriter));
  
  		cl_assert(path_len > (size_t)(root_offset + 1));
  		cl_assert(path[root_offset+1] != '/');
  	}
  
  	cl_assert_equal_i(error, GIT_ITEROVER);
  
  	git_path_diriter_free(&diriter);
  	git__free(root_path);
  }
  

Download