void test_repo_iterator__workdirfilelist_icase(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_vector filelist; cl_git_pass(git_vector_init(&filelist, 100, &git__strcmp_cb)); 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, "kZZZZ")); cl_git_pass(git_vector_insert(&filelist, "L/1")); g_repo = cl_git_sandbox_init("icase"); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE; i_opts.pathlist.strings = (char **)filelist.contents; i_opts.pathlist.count = filelist.length; 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, 3, NULL, 3, 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, 1, NULL); git_iterator_free(i); 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, 5, NULL, 5, 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, 2, NULL, 2, NULL); git_iterator_free(i); git_vector_free(&filelist); }
void test_repo_iterator__workdirfilelist(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_vector filelist; bool default_icase; int expect; cl_git_pass(git_vector_init(&filelist, 100, &git__strcmp_cb)); 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"); /* All indexfilelist iterator tests are "autoexpand with no tree entries" */ /* In this test we DO NOT force a case on the iteratords and verify default behavior. */ i_opts.pathlist.strings = (char **)filelist.contents; i_opts.pathlist.count = filelist.length; 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 = "c"; i_opts.end = NULL; cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts)); default_icase = git_iterator_ignore_case(i); /* (c D e k/1 k/a L ==> 6) vs (c e k/1 k/a ==> 4) */ expect = ((default_icase) ? 6 : 4); expect_iterator_items(i, expect, NULL, expect, NULL); git_iterator_free(i); i_opts.start = NULL; i_opts.end = "e"; cl_git_pass(git_iterator_for_workdir(&i, g_repo, NULL, NULL, &i_opts)); default_icase = git_iterator_ignore_case(i); /* (a B c D e ==> 5) vs (B D L/1 a c e ==> 6) */ expect = ((default_icase) ? 5 : 6); expect_iterator_items(i, expect, NULL, expect, NULL); git_iterator_free(i); git_vector_free(&filelist); }
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__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); }
static void *run_workdir_iterator(void *arg) { int error = 0; git_iterator *iter; const git_index_entry *entry = NULL; cl_git_pass(git_iterator_for_workdir( &iter, _repo, NULL, NULL, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL)); while (!error) { if (entry && entry->mode == GIT_FILEMODE_TREE) { error = git_iterator_advance_into(&entry, iter); if (error == GIT_ENOTFOUND) error = git_iterator_advance(&entry, iter); } else { error = git_iterator_advance(&entry, iter); } if (!error) (void)git_iterator_current_is_ignored(iter); } cl_assert_equal_i(GIT_ITEROVER, error); git_iterator_free(iter); giterr_clear(); return arg; }
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_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_submodule_status__iterator(void) { git_iterator *iter; const git_index_entry *entry; size_t i; static const char *expected[] = { ".gitmodules", "just_a_dir/", "just_a_dir/contents", "just_a_file", "not", "not-submodule", "README.txt", "sm_added_and_uncommited", "sm_changed_file", "sm_changed_head", "sm_changed_index", "sm_changed_untracked_file", "sm_missing_commits", "sm_unchanged", NULL }; static int expected_flags[] = { GIT_STATUS_INDEX_MODIFIED | GIT_STATUS_WT_MODIFIED, /* ".gitmodules" */ 0, /* "just_a_dir/" will be skipped */ GIT_STATUS_CURRENT, /* "just_a_dir/contents" */ GIT_STATUS_CURRENT, /* "just_a_file" */ GIT_STATUS_IGNORED, /* "not" (contains .git) */ GIT_STATUS_IGNORED, /* "not-submodule" (contains .git) */ GIT_STATUS_CURRENT, /* "README.txt */ GIT_STATUS_INDEX_NEW, /* "sm_added_and_uncommited" */ GIT_STATUS_WT_MODIFIED, /* "sm_changed_file" */ GIT_STATUS_WT_MODIFIED, /* "sm_changed_head" */ GIT_STATUS_WT_MODIFIED, /* "sm_changed_index" */ GIT_STATUS_WT_MODIFIED, /* "sm_changed_untracked_file" */ GIT_STATUS_WT_MODIFIED, /* "sm_missing_commits" */ GIT_STATUS_CURRENT, /* "sm_unchanged" */ 0 }; submodule_expectations exp = { 0, expected, expected_flags }; git_status_options opts = GIT_STATUS_OPTIONS_INIT; cl_git_pass(git_iterator_for_workdir(&iter, g_repo, GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES, NULL, NULL)); for (i = 0; !git_iterator_advance(&entry, iter); ++i) cl_assert_equal_s(expected[i], entry->path); git_iterator_free(iter); opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_INCLUDE_UNMODIFIED | GIT_STATUS_OPT_INCLUDE_IGNORED | GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; cl_git_pass(git_status_foreach_ext( g_repo, &opts, confirm_submodule_status, &exp)); }
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); }
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__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__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); }
void test_diff_iterator__workdir_builtin_ignores(void) { git_repository *repo = cl_git_sandbox_init("attr"); 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 } }; 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, 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 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; git_repository *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, 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, NULL, NULL)); 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__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); }
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_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); }