mirror of
https://git.proxmox.com/git/libgit2
synced 2025-11-04 07:09:14 +00:00
8acc3b16ef
Add a new branch that causes a merge conflict to `testrepo` so that we are able to test merging in worktrees.
1474 lines
44 KiB
C
1474 lines
44 KiB
C
#include "clar_libgit2.h"
|
|
#include "iterator.h"
|
|
#include "repository.h"
|
|
#include "fileops.h"
|
|
#include "../submodule/submodule_helpers.h"
|
|
#include "iterator_helpers.h"
|
|
#include <stdarg.h>
|
|
|
|
static git_repository *g_repo;
|
|
|
|
void test_iterator_workdir__initialize(void)
|
|
{
|
|
}
|
|
|
|
void test_iterator_workdir__cleanup(void)
|
|
{
|
|
cl_git_sandbox_cleanup();
|
|
g_repo = NULL;
|
|
}
|
|
|
|
static void workdir_iterator_test(
|
|
const char *sandbox,
|
|
const char *start,
|
|
const char *end,
|
|
int expected_count,
|
|
int expected_ignores,
|
|
const char **expected_names,
|
|
const char *an_ignored_name)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
const git_index_entry *entry;
|
|
int error, count = 0, count_all = 0, count_all_post_reset = 0;
|
|
|
|
g_repo = cl_git_sandbox_init(sandbox);
|
|
|
|
i_opts.flags = GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
i_opts.start = start;
|
|
i_opts.end = end;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
|
|
error = git_iterator_current(&entry, i);
|
|
cl_assert((error == 0 && entry != NULL) ||
|
|
(error == GIT_ITEROVER && entry == NULL));
|
|
|
|
while (entry != NULL) {
|
|
int ignored = git_iterator_current_is_ignored(i);
|
|
|
|
if (S_ISDIR(entry->mode)) {
|
|
cl_git_pass(git_iterator_advance_into(&entry, i));
|
|
continue;
|
|
}
|
|
|
|
if (expected_names != NULL)
|
|
cl_assert_equal_s(expected_names[count_all], entry->path);
|
|
|
|
if (an_ignored_name && strcmp(an_ignored_name,entry->path)==0)
|
|
cl_assert(ignored);
|
|
|
|
if (!ignored)
|
|
count++;
|
|
count_all++;
|
|
|
|
error = git_iterator_advance(&entry, i);
|
|
|
|
cl_assert((error == 0 && entry != NULL) ||
|
|
(error == GIT_ITEROVER && entry == NULL));
|
|
}
|
|
|
|
cl_assert_equal_i(expected_count, count);
|
|
cl_assert_equal_i(expected_count + expected_ignores, count_all);
|
|
|
|
cl_git_pass(git_iterator_reset(i));
|
|
|
|
error = git_iterator_current(&entry, i);
|
|
cl_assert((error == 0 && entry != NULL) ||
|
|
(error == GIT_ITEROVER && entry == NULL));
|
|
|
|
while (entry != NULL) {
|
|
if (S_ISDIR(entry->mode)) {
|
|
cl_git_pass(git_iterator_advance_into(&entry, i));
|
|
continue;
|
|
}
|
|
|
|
if (expected_names != NULL)
|
|
cl_assert_equal_s(
|
|
expected_names[count_all_post_reset], entry->path);
|
|
count_all_post_reset++;
|
|
|
|
error = git_iterator_advance(&entry, i);
|
|
cl_assert(error == 0 || error == GIT_ITEROVER);
|
|
}
|
|
|
|
cl_assert_equal_i(count_all, count_all_post_reset);
|
|
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__0(void)
|
|
{
|
|
workdir_iterator_test("attr", NULL, NULL, 23, 5, NULL, "ign");
|
|
}
|
|
|
|
static const char *status_paths[] = {
|
|
"current_file",
|
|
"ignored_file",
|
|
"modified_file",
|
|
"new_file",
|
|
"staged_changes",
|
|
"staged_changes_modified_file",
|
|
"staged_delete_modified_file",
|
|
"staged_new_file",
|
|
"staged_new_file_modified_file",
|
|
"subdir.txt",
|
|
"subdir/current_file",
|
|
"subdir/modified_file",
|
|
"subdir/new_file",
|
|
"\xe8\xbf\x99",
|
|
NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", NULL, NULL, 13, 1, status_paths, "ignored_file");
|
|
}
|
|
|
|
static const char *status_paths_range_0[] = {
|
|
"staged_changes",
|
|
"staged_changes_modified_file",
|
|
"staged_delete_modified_file",
|
|
"staged_new_file",
|
|
"staged_new_file_modified_file",
|
|
NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1_ranged_0(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "staged", "staged", 5, 0, status_paths_range_0, NULL);
|
|
}
|
|
|
|
static const char *status_paths_range_1[] = {
|
|
"modified_file", NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1_ranged_1(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "modified_file", "modified_file",
|
|
1, 0, status_paths_range_1, NULL);
|
|
}
|
|
|
|
static const char *status_paths_range_3[] = {
|
|
"subdir.txt",
|
|
"subdir/current_file",
|
|
"subdir/modified_file",
|
|
NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1_ranged_3(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "subdir", "subdir/modified_file",
|
|
3, 0, status_paths_range_3, NULL);
|
|
}
|
|
|
|
static const char *status_paths_range_4[] = {
|
|
"subdir/current_file",
|
|
"subdir/modified_file",
|
|
"subdir/new_file",
|
|
"\xe8\xbf\x99",
|
|
NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1_ranged_4(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "subdir/", NULL, 4, 0, status_paths_range_4, NULL);
|
|
}
|
|
|
|
static const char *status_paths_range_5[] = {
|
|
"subdir/modified_file",
|
|
NULL
|
|
};
|
|
|
|
void test_iterator_workdir__1_ranged_5(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "subdir/modified_file", "subdir/modified_file",
|
|
1, 0, status_paths_range_5, NULL);
|
|
}
|
|
|
|
void test_iterator_workdir__1_ranged_5_1_ranged_empty_0(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "\xff_does_not_exist", NULL,
|
|
0, 0, NULL, NULL);
|
|
}
|
|
|
|
void test_iterator_workdir__1_ranged_empty_1(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", "empty", "empty",
|
|
0, 0, NULL, NULL);
|
|
}
|
|
|
|
void test_iterator_workdir__1_ranged_empty_2(void)
|
|
{
|
|
workdir_iterator_test(
|
|
"status", NULL, "aaaa_empty_before",
|
|
0, 0, NULL, NULL);
|
|
}
|
|
|
|
void test_iterator_workdir__builtin_ignores(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
const git_index_entry *entry;
|
|
int idx;
|
|
static struct {
|
|
const char *path;
|
|
bool ignored;
|
|
} expected[] = {
|
|
{ "dir/", true },
|
|
{ "file", false },
|
|
{ "ign", true },
|
|
{ "macro_bad", false },
|
|
{ "macro_test", false },
|
|
{ "root_test1", false },
|
|
{ "root_test2", false },
|
|
{ "root_test3", false },
|
|
{ "root_test4.txt", false },
|
|
{ "sub/", false },
|
|
{ "sub/.gitattributes", false },
|
|
{ "sub/abc", false },
|
|
{ "sub/dir/", true },
|
|
{ "sub/file", false },
|
|
{ "sub/ign/", true },
|
|
{ "sub/sub/", false },
|
|
{ "sub/sub/.gitattributes", false },
|
|
{ "sub/sub/dir", false }, /* file is not actually a dir */
|
|
{ "sub/sub/file", false },
|
|
{ NULL, false }
|
|
};
|
|
|
|
g_repo = cl_git_sandbox_init("attr");
|
|
|
|
cl_git_pass(p_mkdir("attr/sub/sub/.git", 0777));
|
|
cl_git_mkfile("attr/sub/.git", "whatever");
|
|
|
|
i_opts.flags = GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
i_opts.start = "dir";
|
|
i_opts.end = "sub/sub/file";
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, NULL, NULL, &i_opts));
|
|
cl_git_pass(git_iterator_current(&entry, i));
|
|
|
|
for (idx = 0; entry != NULL; ++idx) {
|
|
int ignored = git_iterator_current_is_ignored(i);
|
|
|
|
cl_assert_equal_s(expected[idx].path, entry->path);
|
|
cl_assert_(ignored == expected[idx].ignored, expected[idx].path);
|
|
|
|
if (!ignored &&
|
|
(entry->mode == GIT_FILEMODE_TREE ||
|
|
entry->mode == GIT_FILEMODE_COMMIT))
|
|
{
|
|
/* it is possible to advance "into" a submodule */
|
|
cl_git_pass(git_iterator_advance_into(&entry, i));
|
|
} else {
|
|
int error = git_iterator_advance(&entry, i);
|
|
cl_assert(!error || error == GIT_ITEROVER);
|
|
}
|
|
}
|
|
|
|
cl_assert(expected[idx].path == NULL);
|
|
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
static void check_wd_first_through_third_range(
|
|
git_repository *repo, const char *start, const char *end)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
const git_index_entry *entry;
|
|
int error, idx;
|
|
static const char *expected[] = { "FIRST", "second", "THIRD", NULL };
|
|
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
i_opts.start = start;
|
|
i_opts.end = end;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, repo, NULL, NULL, &i_opts));
|
|
cl_git_pass(git_iterator_current(&entry, i));
|
|
|
|
for (idx = 0; entry != NULL; ++idx) {
|
|
cl_assert_equal_s(expected[idx], entry->path);
|
|
|
|
error = git_iterator_advance(&entry, i);
|
|
cl_assert(!error || error == GIT_ITEROVER);
|
|
}
|
|
|
|
cl_assert(expected[idx] == NULL);
|
|
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__handles_icase_range(void)
|
|
{
|
|
g_repo = cl_git_sandbox_init("empty_standard_repo");
|
|
cl_git_remove_placeholders(git_repository_path(g_repo), "dummy-marker.txt");
|
|
|
|
cl_git_mkfile("empty_standard_repo/before", "whatever\n");
|
|
cl_git_mkfile("empty_standard_repo/FIRST", "whatever\n");
|
|
cl_git_mkfile("empty_standard_repo/second", "whatever\n");
|
|
cl_git_mkfile("empty_standard_repo/THIRD", "whatever\n");
|
|
cl_git_mkfile("empty_standard_repo/zafter", "whatever\n");
|
|
cl_git_mkfile("empty_standard_repo/Zlast", "whatever\n");
|
|
|
|
check_wd_first_through_third_range(g_repo, "first", "third");
|
|
check_wd_first_through_third_range(g_repo, "FIRST", "THIRD");
|
|
check_wd_first_through_third_range(g_repo, "first", "THIRD");
|
|
check_wd_first_through_third_range(g_repo, "FIRST", "third");
|
|
check_wd_first_through_third_range(g_repo, "FirSt", "tHiRd");
|
|
}
|
|
|
|
/*
|
|
* The workdir iterator is like the filesystem iterator, but honors
|
|
* special git type constructs (ignores, submodules, etc).
|
|
*/
|
|
|
|
void test_iterator_workdir__icase(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 20, NULL, 20, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
i_opts.flags = GIT_ITERATOR_INCLUDE_TREES;
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 22, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
i_opts.flags = GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 12, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__icase_starts_and_ends(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* auto expand with no tree entries */
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 7, NULL, 7, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 3, NULL, 3, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 8, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 4, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE | GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 5, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 1, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with no tree entries */
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 13, NULL, 13, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 5, NULL, 5, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 14, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 6, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 9, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/Z";
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, 1, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
static void build_workdir_tree(const char *root, int dirs, int subs)
|
|
{
|
|
int i, j;
|
|
char buf[64], sub[64];
|
|
|
|
for (i = 0; i < dirs; ++i) {
|
|
if (i % 2 == 0) {
|
|
p_snprintf(buf, sizeof(buf), "%s/dir%02d", root, i);
|
|
cl_git_pass(git_futils_mkdir(buf, 0775, GIT_MKDIR_PATH));
|
|
|
|
p_snprintf(buf, sizeof(buf), "%s/dir%02d/file", root, i);
|
|
cl_git_mkfile(buf, buf);
|
|
buf[strlen(buf) - 5] = '\0';
|
|
} else {
|
|
p_snprintf(buf, sizeof(buf), "%s/DIR%02d", root, i);
|
|
cl_git_pass(git_futils_mkdir(buf, 0775, GIT_MKDIR_PATH));
|
|
}
|
|
|
|
for (j = 0; j < subs; ++j) {
|
|
switch (j % 4) {
|
|
case 0: p_snprintf(sub, sizeof(sub), "%s/sub%02d", buf, j); break;
|
|
case 1: p_snprintf(sub, sizeof(sub), "%s/sUB%02d", buf, j); break;
|
|
case 2: p_snprintf(sub, sizeof(sub), "%s/Sub%02d", buf, j); break;
|
|
case 3: p_snprintf(sub, sizeof(sub), "%s/SUB%02d", buf, j); break;
|
|
}
|
|
cl_git_pass(git_futils_mkdir(sub, 0775, GIT_MKDIR_PATH));
|
|
|
|
if (j % 2 == 0) {
|
|
size_t sublen = strlen(sub);
|
|
memcpy(&sub[sublen], "/file", sizeof("/file"));
|
|
cl_git_mkfile(sub, sub);
|
|
sub[sublen] = '\0';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void test_iterator_workdir__depth(void)
|
|
{
|
|
git_iterator *iter;
|
|
git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
build_workdir_tree("icase", 10, 10);
|
|
build_workdir_tree("icase/DIR01/sUB01", 50, 0);
|
|
build_workdir_tree("icase/dir02/sUB01", 50, 0);
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(&iter, g_repo, NULL, NULL, &iter_opts));
|
|
expect_iterator_items(iter, 125, NULL, 125, NULL);
|
|
git_iterator_free(iter);
|
|
|
|
/* auto expand with tree entries (empty dirs silently skipped) */
|
|
iter_opts.flags = GIT_ITERATOR_INCLUDE_TREES;
|
|
cl_git_pass(git_iterator_for_workdir(&iter, g_repo, NULL, NULL, &iter_opts));
|
|
expect_iterator_items(iter, 337, NULL, 337, NULL);
|
|
git_iterator_free(iter);
|
|
}
|
|
|
|
/* The filesystem iterator is a workdir iterator without any special
|
|
* workdir handling capabilities (ignores, submodules, etc).
|
|
*/
|
|
void test_iterator_workdir__filesystem(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
static const char *expect_base[] = {
|
|
"DIR01/Sub02/file",
|
|
"DIR01/sub00/file",
|
|
"current_file",
|
|
"dir00/Sub02/file",
|
|
"dir00/file",
|
|
"dir00/sub00/file",
|
|
"modified_file",
|
|
"new_file",
|
|
NULL,
|
|
};
|
|
static const char *expect_trees[] = {
|
|
"DIR01/",
|
|
"DIR01/SUB03/",
|
|
"DIR01/Sub02/",
|
|
"DIR01/Sub02/file",
|
|
"DIR01/sUB01/",
|
|
"DIR01/sub00/",
|
|
"DIR01/sub00/file",
|
|
"current_file",
|
|
"dir00/",
|
|
"dir00/SUB03/",
|
|
"dir00/Sub02/",
|
|
"dir00/Sub02/file",
|
|
"dir00/file",
|
|
"dir00/sUB01/",
|
|
"dir00/sub00/",
|
|
"dir00/sub00/file",
|
|
"modified_file",
|
|
"new_file",
|
|
NULL,
|
|
};
|
|
static const char *expect_noauto[] = {
|
|
"DIR01/",
|
|
"current_file",
|
|
"dir00/",
|
|
"modified_file",
|
|
"new_file",
|
|
NULL,
|
|
};
|
|
|
|
g_repo = cl_git_sandbox_init("status");
|
|
|
|
build_workdir_tree("status/subdir", 2, 4);
|
|
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", NULL));
|
|
expect_iterator_items(i, 8, expect_base, 8, expect_base);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.flags = GIT_ITERATOR_INCLUDE_TREES;
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
|
|
expect_iterator_items(i, 18, expect_trees, 18, expect_trees);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.flags = GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
|
|
expect_iterator_items(i, 5, expect_noauto, 18, expect_trees);
|
|
git_iterator_free(i);
|
|
|
|
git__tsort((void **)expect_base, 8, (git__tsort_cmp)git__strcasecmp);
|
|
git__tsort((void **)expect_trees, 18, (git__tsort_cmp)git__strcasecmp);
|
|
git__tsort((void **)expect_noauto, 5, (git__tsort_cmp)git__strcasecmp);
|
|
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
|
|
expect_iterator_items(i, 8, expect_base, 8, expect_base);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES;
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
|
|
expect_iterator_items(i, 18, expect_trees, 18, expect_trees);
|
|
git_iterator_free(i);
|
|
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
|
|
expect_iterator_items(i, 5, expect_noauto, 18, expect_trees);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__filesystem2(void)
|
|
{
|
|
git_iterator *i;
|
|
static const char *expect_base[] = {
|
|
"heads/br2",
|
|
"heads/dir",
|
|
"heads/ident",
|
|
"heads/long-file-name",
|
|
"heads/master",
|
|
"heads/merge-conflict",
|
|
"heads/packed-test",
|
|
"heads/subtrees",
|
|
"heads/test",
|
|
"heads/testrepo-worktree",
|
|
"tags/e90810b",
|
|
"tags/foo/bar",
|
|
"tags/foo/foo/bar",
|
|
"tags/point_to_blob",
|
|
"tags/test",
|
|
NULL,
|
|
};
|
|
|
|
g_repo = cl_git_sandbox_init("testrepo");
|
|
|
|
cl_git_pass(git_iterator_for_filesystem(
|
|
&i, "testrepo/.git/refs", NULL));
|
|
expect_iterator_items(i, 15, expect_base, 15, expect_base);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Lots of empty dirs, or nearly empty ones, make the old workdir
|
|
* iterator cry. Also, segfault.
|
|
*/
|
|
void test_iterator_workdir__filesystem_gunk(void)
|
|
{
|
|
git_iterator *i;
|
|
git_buf parent = GIT_BUF_INIT;
|
|
int n;
|
|
|
|
if (!cl_is_env_set("GITTEST_INVASIVE_SPEED"))
|
|
cl_skip();
|
|
|
|
g_repo = cl_git_sandbox_init("testrepo");
|
|
|
|
for (n = 0; n < 100000; n++) {
|
|
git_buf_clear(&parent);
|
|
git_buf_printf(&parent, "%s/refs/heads/foo/%d/subdir",
|
|
git_repository_path(g_repo), n);
|
|
cl_assert(!git_buf_oom(&parent));
|
|
|
|
cl_git_pass(git_futils_mkdir(parent.ptr, 0775, GIT_MKDIR_PATH));
|
|
}
|
|
|
|
cl_git_pass(git_iterator_for_filesystem(&i, "testrepo/.git/refs", NULL));
|
|
|
|
/* should only have 13 items, since we're not asking for trees to be
|
|
* returned. the goal of this test is simply to not crash.
|
|
*/
|
|
expect_iterator_items(i, 13, NULL, 13, NULL);
|
|
git_iterator_free(i);
|
|
git_buf_free(&parent);
|
|
}
|
|
|
|
void test_iterator_workdir__skips_unreadable_dirs(void)
|
|
{
|
|
git_iterator *i;
|
|
const git_index_entry *e;
|
|
|
|
if (!cl_is_chmod_supported())
|
|
return;
|
|
|
|
#ifndef GIT_WIN32
|
|
if (geteuid() == 0)
|
|
cl_skip();
|
|
#endif
|
|
|
|
g_repo = cl_git_sandbox_init("empty_standard_repo");
|
|
|
|
cl_must_pass(p_mkdir("empty_standard_repo/r", 0777));
|
|
cl_git_mkfile("empty_standard_repo/r/a", "hello");
|
|
cl_must_pass(p_mkdir("empty_standard_repo/r/b", 0777));
|
|
cl_git_mkfile("empty_standard_repo/r/b/problem", "not me");
|
|
cl_must_pass(p_chmod("empty_standard_repo/r/b", 0000));
|
|
cl_must_pass(p_mkdir("empty_standard_repo/r/c", 0777));
|
|
cl_git_mkfile("empty_standard_repo/r/c/foo", "aloha");
|
|
cl_git_mkfile("empty_standard_repo/r/d", "final");
|
|
|
|
cl_git_pass(git_iterator_for_filesystem(
|
|
&i, "empty_standard_repo/r", NULL));
|
|
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* a */
|
|
cl_assert_equal_s("a", e->path);
|
|
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* c/foo */
|
|
cl_assert_equal_s("c/foo", e->path);
|
|
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* d */
|
|
cl_assert_equal_s("d", e->path);
|
|
|
|
cl_must_pass(p_chmod("empty_standard_repo/r/b", 0777));
|
|
|
|
cl_assert_equal_i(GIT_ITEROVER, git_iterator_advance(&e, i));
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__skips_fifos_and_special_files(void)
|
|
{
|
|
#ifndef GIT_WIN32
|
|
git_iterator *i;
|
|
const git_index_entry *e;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
g_repo = cl_git_sandbox_init("empty_standard_repo");
|
|
|
|
cl_must_pass(p_mkdir("empty_standard_repo/dir", 0777));
|
|
cl_git_mkfile("empty_standard_repo/file", "not me");
|
|
|
|
cl_assert(!mkfifo("empty_standard_repo/fifo", 0777));
|
|
cl_assert(!access("empty_standard_repo/fifo", F_OK));
|
|
|
|
i_opts.flags = GIT_ITERATOR_INCLUDE_TREES |
|
|
GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
cl_git_pass(git_iterator_for_filesystem(
|
|
&i, "empty_standard_repo", &i_opts));
|
|
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* .git */
|
|
cl_assert(S_ISDIR(e->mode));
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* dir */
|
|
cl_assert(S_ISDIR(e->mode));
|
|
/* skips fifo */
|
|
cl_git_pass(git_iterator_advance(&e, i)); /* file */
|
|
cl_assert(S_ISREG(e->mode));
|
|
|
|
cl_assert_equal_i(GIT_ITEROVER, git_iterator_advance(&e, i));
|
|
|
|
git_iterator_free(i);
|
|
#endif
|
|
}
|
|
|
|
void test_iterator_workdir__pathlist(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 100, NULL));
|
|
cl_git_pass(git_vector_insert(&filelist, "a"));
|
|
cl_git_pass(git_vector_insert(&filelist, "B"));
|
|
cl_git_pass(git_vector_insert(&filelist, "c"));
|
|
cl_git_pass(git_vector_insert(&filelist, "D"));
|
|
cl_git_pass(git_vector_insert(&filelist, "e"));
|
|
cl_git_pass(git_vector_insert(&filelist, "k.a"));
|
|
cl_git_pass(git_vector_insert(&filelist, "k.b"));
|
|
cl_git_pass(git_vector_insert(&filelist, "k/1"));
|
|
cl_git_pass(git_vector_insert(&filelist, "k/a"));
|
|
cl_git_pass(git_vector_insert(&filelist, "kZZZZZZZ"));
|
|
cl_git_pass(git_vector_insert(&filelist, "L/1"));
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* Test iterators without returning tree entries (but autoexpanding.) */
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
|
|
/* Case sensitive */
|
|
{
|
|
const char *expected[] = {
|
|
"B", "D", "L/1", "a", "c", "e", "k/1", "k/a" };
|
|
size_t expected_len = 8;
|
|
|
|
i_opts.start = NULL;
|
|
i_opts.end = NULL;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Case INsensitive */
|
|
{
|
|
const char *expected[] = {
|
|
"a", "B", "c", "D", "e", "k/1", "k/a", "L/1" };
|
|
size_t expected_len = 8;
|
|
|
|
i_opts.start = NULL;
|
|
i_opts.end = NULL;
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Set a start, but no end. Case sensitive. */
|
|
{
|
|
const char *expected[] = { "c", "e", "k/1", "k/a" };
|
|
size_t expected_len = 4;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = NULL;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Set a start, but no end. Case INsensitive. */
|
|
{
|
|
const char *expected[] = { "c", "D", "e", "k/1", "k/a", "L/1" };
|
|
size_t expected_len = 6;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = NULL;
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Set no start, but an end. Case sensitive. */
|
|
{
|
|
const char *expected[] = { "B", "D", "L/1", "a", "c", "e" };
|
|
size_t expected_len = 6;
|
|
|
|
i_opts.start = NULL;
|
|
i_opts.end = "e";
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Set no start, but an end. Case INsensitive. */
|
|
{
|
|
const char *expected[] = { "a", "B", "c", "D", "e" };
|
|
size_t expected_len = 5;
|
|
|
|
i_opts.start = NULL;
|
|
i_opts.end = "e";
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Start and an end, case sensitive */
|
|
{
|
|
const char *expected[] = { "c", "e", "k/1" };
|
|
size_t expected_len = 3;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Start and an end, case sensitive */
|
|
{
|
|
const char *expected[] = { "k/1" };
|
|
size_t expected_len = 1;
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/D";
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Start and an end, case INsensitive */
|
|
{
|
|
const char *expected[] = { "c", "D", "e", "k/1", "k/a" };
|
|
size_t expected_len = 5;
|
|
|
|
i_opts.start = "c";
|
|
i_opts.end = "k/D";
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Start and an end, case INsensitive */
|
|
{
|
|
const char *expected[] = { "k/1", "k/a" };
|
|
size_t expected_len = 2;
|
|
|
|
i_opts.start = "k";
|
|
i_opts.end = "k/D";
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
git_vector_free(&filelist);
|
|
}
|
|
|
|
void test_iterator_workdir__pathlist_with_dirs(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 5, NULL));
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* Test that a prefix `k` matches folders, even without trailing slash */
|
|
{
|
|
const char *expected[] = { "k/1", "k/B", "k/D", "k/a", "k/c" };
|
|
size_t expected_len = 5;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "k"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that a `k/` matches a folder */
|
|
{
|
|
const char *expected[] = { "k/1", "k/B", "k/D", "k/a", "k/c" };
|
|
size_t expected_len = 5;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "k/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* When the iterator is case sensitive, ensure we can't lookup the
|
|
* directory with the wrong case.
|
|
*/
|
|
{
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "K/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
cl_git_fail_with(GIT_ITEROVER, git_iterator_advance(NULL, i));
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that case insensitive matching works. */
|
|
{
|
|
const char *expected[] = { "k/1", "k/a", "k/B", "k/c", "k/D" };
|
|
size_t expected_len = 5;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "K/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that case insensitive matching works without trailing slash. */
|
|
{
|
|
const char *expected[] = { "k/1", "k/a", "k/B", "k/c", "k/D" };
|
|
size_t expected_len = 5;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "K"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
git_vector_free(&filelist);
|
|
}
|
|
|
|
static void create_paths(const char *root, int depth)
|
|
{
|
|
git_buf fullpath = GIT_BUF_INIT;
|
|
size_t root_len;
|
|
int i;
|
|
|
|
cl_git_pass(git_buf_puts(&fullpath, root));
|
|
cl_git_pass(git_buf_putc(&fullpath, '/'));
|
|
|
|
root_len = fullpath.size;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
bool file = (depth == 0 || (i % 2) == 0);
|
|
git_buf_truncate(&fullpath, root_len);
|
|
cl_git_pass(git_buf_printf(&fullpath, "item%d", i));
|
|
|
|
if (file) {
|
|
cl_git_rewritefile(fullpath.ptr, "This is a file!\n");
|
|
} else {
|
|
cl_must_pass(p_mkdir(fullpath.ptr, 0777));
|
|
|
|
if (depth > 0)
|
|
create_paths(fullpath.ptr, (depth - 1));
|
|
}
|
|
}
|
|
|
|
git_buf_free(&fullpath);
|
|
}
|
|
|
|
void test_iterator_workdir__pathlist_for_deeply_nested_item(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 5, NULL));
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
create_paths(git_repository_workdir(g_repo), 3);
|
|
|
|
/* Ensure that we find the single path we're interested in, and we find
|
|
* it efficiently, and don't stat the entire world to get there.
|
|
*/
|
|
{
|
|
const char *expected[] = { "item1/item3/item5/item7" };
|
|
size_t expected_len = 1;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "item1/item3/item5/item7"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
cl_assert_equal_i(4, i->stat_calls);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Ensure that we find the single path we're interested in, and we find
|
|
* it efficiently, and don't stat the entire world to get there.
|
|
*/
|
|
{
|
|
const char *expected[] = {
|
|
"item1/item3/item5/item0", "item1/item3/item5/item1",
|
|
"item1/item3/item5/item2", "item1/item3/item5/item3",
|
|
"item1/item3/item5/item4", "item1/item3/item5/item5",
|
|
"item1/item3/item5/item6", "item1/item3/item5/item7",
|
|
};
|
|
size_t expected_len = 8;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "item1/item3/item5/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
cl_assert_equal_i(11, i->stat_calls);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Ensure that we find the single path we're interested in, and we find
|
|
* it efficiently, and don't stat the entire world to get there.
|
|
*/
|
|
{
|
|
const char *expected[] = {
|
|
"item1/item3/item0",
|
|
"item1/item3/item1/item0", "item1/item3/item1/item1",
|
|
"item1/item3/item1/item2", "item1/item3/item1/item3",
|
|
"item1/item3/item1/item4", "item1/item3/item1/item5",
|
|
"item1/item3/item1/item6", "item1/item3/item1/item7",
|
|
"item1/item3/item2",
|
|
"item1/item3/item3/item0", "item1/item3/item3/item1",
|
|
"item1/item3/item3/item2", "item1/item3/item3/item3",
|
|
"item1/item3/item3/item4", "item1/item3/item3/item5",
|
|
"item1/item3/item3/item6", "item1/item3/item3/item7",
|
|
"item1/item3/item4",
|
|
"item1/item3/item5/item0", "item1/item3/item5/item1",
|
|
"item1/item3/item5/item2", "item1/item3/item5/item3",
|
|
"item1/item3/item5/item4", "item1/item3/item5/item5",
|
|
"item1/item3/item5/item6", "item1/item3/item5/item7",
|
|
"item1/item3/item6",
|
|
"item1/item3/item7/item0", "item1/item3/item7/item1",
|
|
"item1/item3/item7/item2", "item1/item3/item7/item3",
|
|
"item1/item3/item7/item4", "item1/item3/item7/item5",
|
|
"item1/item3/item7/item6", "item1/item3/item7/item7",
|
|
};
|
|
size_t expected_len = 36;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "item1/item3/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
cl_assert_equal_i(42, i->stat_calls);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Ensure that we find the single path we're interested in, and we find
|
|
* it efficiently, and don't stat the entire world to get there.
|
|
*/
|
|
{
|
|
const char *expected[] = {
|
|
"item0", "item1/item2", "item5/item7/item4", "item6",
|
|
"item7/item3/item1/item6" };
|
|
size_t expected_len = 5;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "item7/item3/item1/item6"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item6"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item5/item7/item4"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item1/item2"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item0"));
|
|
|
|
/* also add some things that don't exist or don't match the right type */
|
|
cl_git_pass(git_vector_insert(&filelist, "item2/"));
|
|
cl_git_pass(git_vector_insert(&filelist, "itemN"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item1/itemA"));
|
|
cl_git_pass(git_vector_insert(&filelist, "item5/item3/item4/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
cl_assert_equal_i(14, i->stat_calls);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
git_vector_free(&filelist);
|
|
}
|
|
|
|
void test_iterator_workdir__bounded_submodules(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
git_index *index;
|
|
git_tree *head;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 5, NULL));
|
|
|
|
g_repo = setup_fixture_submod2();
|
|
cl_git_pass(git_repository_index(&index, g_repo));
|
|
cl_git_pass(git_repository_head_tree(&head, g_repo));
|
|
|
|
/* Test that a submodule matches */
|
|
{
|
|
const char *expected[] = { "sm_changed_head" };
|
|
size_t expected_len = 1;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "sm_changed_head"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, index, head, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that a submodule still matches when suffixed with a '/' */
|
|
{
|
|
const char *expected[] = { "sm_changed_head" };
|
|
size_t expected_len = 1;
|
|
|
|
git_vector_clear(&filelist);
|
|
cl_git_pass(git_vector_insert(&filelist, "sm_changed_head/"));
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, index, head, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that start/end work with a submodule */
|
|
{
|
|
const char *expected[] = { "sm_changed_head", "sm_changed_index" };
|
|
size_t expected_len = 2;
|
|
|
|
i_opts.start = "sm_changed_head";
|
|
i_opts.end = "sm_changed_index";
|
|
i_opts.pathlist.strings = NULL;
|
|
i_opts.pathlist.count = 0;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, index, head, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
/* Test that start and end allow '/' suffixes of submodules */
|
|
{
|
|
const char *expected[] = { "sm_changed_head", "sm_changed_index" };
|
|
size_t expected_len = 2;
|
|
|
|
i_opts.start = "sm_changed_head";
|
|
i_opts.end = "sm_changed_index";
|
|
i_opts.pathlist.strings = NULL;
|
|
i_opts.pathlist.count = 0;
|
|
i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, index, head, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
git_vector_free(&filelist);
|
|
git_index_free(index);
|
|
git_tree_free(head);
|
|
}
|
|
|
|
void test_iterator_workdir__advance_over(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
i_opts.flags |= GIT_ITERATOR_DONT_IGNORE_CASE |
|
|
GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* create an empty directory */
|
|
cl_must_pass(p_mkdir("icase/empty", 0777));
|
|
|
|
/* create a directory in which all contents are ignored */
|
|
cl_must_pass(p_mkdir("icase/all_ignored", 0777));
|
|
cl_git_rewritefile("icase/all_ignored/one", "This is ignored\n");
|
|
cl_git_rewritefile("icase/all_ignored/two", "This, too, is ignored\n");
|
|
cl_git_rewritefile("icase/all_ignored/.gitignore", ".gitignore\none\ntwo\n");
|
|
|
|
/* create a directory in which not all contents are ignored */
|
|
cl_must_pass(p_mkdir("icase/some_ignored", 0777));
|
|
cl_git_rewritefile("icase/some_ignored/one", "This is ignored\n");
|
|
cl_git_rewritefile("icase/some_ignored/two", "This is not ignored\n");
|
|
cl_git_rewritefile("icase/some_ignored/.gitignore", ".gitignore\none\n");
|
|
|
|
/* create a directory which has some empty children */
|
|
cl_must_pass(p_mkdir("icase/empty_children", 0777));
|
|
cl_must_pass(p_mkdir("icase/empty_children/empty1", 0777));
|
|
cl_must_pass(p_mkdir("icase/empty_children/empty2", 0777));
|
|
cl_must_pass(p_mkdir("icase/empty_children/empty3", 0777));
|
|
|
|
/* create a directory which will disappear! */
|
|
cl_must_pass(p_mkdir("icase/missing_directory", 0777));
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
|
|
cl_must_pass(p_rmdir("icase/missing_directory"));
|
|
|
|
expect_advance_over(i, "B", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "D", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "F", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "H", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "J", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "L/", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "a", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "all_ignored/", GIT_ITERATOR_STATUS_IGNORED);
|
|
expect_advance_over(i, "c", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "e", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "empty/", GIT_ITERATOR_STATUS_EMPTY);
|
|
expect_advance_over(i, "empty_children/", GIT_ITERATOR_STATUS_EMPTY);
|
|
expect_advance_over(i, "g", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "i", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "k/", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "missing_directory/", GIT_ITERATOR_STATUS_EMPTY);
|
|
expect_advance_over(i, "some_ignored/", GIT_ITERATOR_STATUS_NORMAL);
|
|
|
|
cl_git_fail_with(GIT_ITEROVER, git_iterator_advance(NULL, i));
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__advance_over_with_pathlist(void)
|
|
{
|
|
git_vector pathlist = GIT_VECTOR_INIT;
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
git_vector_insert(&pathlist, "dirA/subdir1/subdir2/file");
|
|
git_vector_insert(&pathlist, "dirB/subdir1/subdir2");
|
|
git_vector_insert(&pathlist, "dirC/subdir1/nonexistent");
|
|
git_vector_insert(&pathlist, "dirD/subdir1/nonexistent");
|
|
git_vector_insert(&pathlist, "dirD/subdir1/subdir2");
|
|
git_vector_insert(&pathlist, "dirD/nonexistent");
|
|
|
|
i_opts.pathlist.strings = (char **)pathlist.contents;
|
|
i_opts.pathlist.count = pathlist.length;
|
|
i_opts.flags |= GIT_ITERATOR_DONT_IGNORE_CASE |
|
|
GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* Create a directory that has a file that is included in our pathlist */
|
|
cl_must_pass(p_mkdir("icase/dirA", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirA/subdir1", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirA/subdir1/subdir2", 0777));
|
|
cl_git_rewritefile("icase/dirA/subdir1/subdir2/file", "foo!");
|
|
|
|
/* Create a directory that has a directory that is included in our pathlist */
|
|
cl_must_pass(p_mkdir("icase/dirB", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirB/subdir1", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirB/subdir1/subdir2", 0777));
|
|
cl_git_rewritefile("icase/dirB/subdir1/subdir2/file", "foo!");
|
|
|
|
/* Create a directory that would contain an entry in our pathlist, but
|
|
* that entry does not actually exist. We don't know this until we
|
|
* advance_over it. We want to distinguish this from an actually empty
|
|
* or ignored directory.
|
|
*/
|
|
cl_must_pass(p_mkdir("icase/dirC", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirC/subdir1", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirC/subdir1/subdir2", 0777));
|
|
cl_git_rewritefile("icase/dirC/subdir1/subdir2/file", "foo!");
|
|
|
|
/* Create a directory that has a mix of actual and nonexistent paths */
|
|
cl_must_pass(p_mkdir("icase/dirD", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirD/subdir1", 0777));
|
|
cl_must_pass(p_mkdir("icase/dirD/subdir1/subdir2", 0777));
|
|
cl_git_rewritefile("icase/dirD/subdir1/subdir2/file", "foo!");
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
|
|
expect_advance_over(i, "dirA/", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "dirB/", GIT_ITERATOR_STATUS_NORMAL);
|
|
expect_advance_over(i, "dirC/", GIT_ITERATOR_STATUS_FILTERED);
|
|
expect_advance_over(i, "dirD/", GIT_ITERATOR_STATUS_NORMAL);
|
|
|
|
cl_git_fail_with(GIT_ITEROVER, git_iterator_advance(NULL, i));
|
|
git_iterator_free(i);
|
|
git_vector_free(&pathlist);
|
|
}
|
|
|
|
void test_iterator_workdir__advance_into(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
i_opts.flags |= GIT_ITERATOR_DONT_IGNORE_CASE |
|
|
GIT_ITERATOR_DONT_AUTOEXPAND;
|
|
|
|
cl_must_pass(p_mkdir("icase/Empty", 0777));
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_advance_into(i, "B");
|
|
expect_advance_into(i, "D");
|
|
expect_advance_into(i, "Empty/");
|
|
expect_advance_into(i, "F");
|
|
expect_advance_into(i, "H");
|
|
expect_advance_into(i, "J");
|
|
expect_advance_into(i, "L/");
|
|
expect_advance_into(i, "L/1");
|
|
expect_advance_into(i, "L/B");
|
|
expect_advance_into(i, "L/D");
|
|
expect_advance_into(i, "L/a");
|
|
expect_advance_into(i, "L/c");
|
|
expect_advance_into(i, "a");
|
|
expect_advance_into(i, "c");
|
|
expect_advance_into(i, "e");
|
|
expect_advance_into(i, "g");
|
|
expect_advance_into(i, "i");
|
|
expect_advance_into(i, "k/");
|
|
expect_advance_into(i, "k/1");
|
|
expect_advance_into(i, "k/B");
|
|
expect_advance_into(i, "k/D");
|
|
expect_advance_into(i, "k/a");
|
|
expect_advance_into(i, "k/c");
|
|
|
|
cl_git_fail_with(GIT_ITEROVER, git_iterator_advance(NULL, i));
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_iterator_workdir__pathlist_with_directory(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
|
|
const char *expected[] = { "subdir/README", "subdir/new.txt",
|
|
"subdir/subdir2/README", "subdir/subdir2/new.txt" };
|
|
size_t expected_len = 4;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 100, &git__strcmp_cb));
|
|
cl_git_pass(git_vector_insert(&filelist, "subdir/"));
|
|
|
|
g_repo = cl_git_sandbox_init("testrepo2");
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags |= GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
|
|
git_vector_free(&filelist);
|
|
}
|
|
|
|
void test_iterator_workdir__pathlist_with_directory_include_trees(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT;
|
|
git_vector filelist;
|
|
|
|
const char *expected[] = { "subdir/", "subdir/README", "subdir/new.txt",
|
|
"subdir/subdir2/", "subdir/subdir2/README", "subdir/subdir2/new.txt", };
|
|
size_t expected_len = 6;
|
|
|
|
cl_git_pass(git_vector_init(&filelist, 100, &git__strcmp_cb));
|
|
cl_git_pass(git_vector_insert(&filelist, "subdir/"));
|
|
|
|
g_repo = cl_git_sandbox_init("testrepo2");
|
|
|
|
i_opts.pathlist.strings = (char **)filelist.contents;
|
|
i_opts.pathlist.count = filelist.length;
|
|
i_opts.flags |= GIT_ITERATOR_DONT_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES;
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts));
|
|
expect_iterator_items(i, expected_len, expected, expected_len, expected);
|
|
git_iterator_free(i);
|
|
|
|
git_vector_free(&filelist);
|
|
}
|
|
|