void test_repo_iterator__tree(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_tree *head; g_repo = cl_git_sandbox_init("icase"); cl_git_pass(git_repository_head_tree(&head, g_repo)); /* auto expand with no tree entries */ cl_git_pass(git_iterator_for_tree(&i, head, NULL)); 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_tree(&i, head, &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_tree(&i, head, &i_opts)); expect_iterator_items(i, 12, NULL, 22, NULL); git_iterator_free(i); git_tree_free(head); }
void test_repo_iterator__treefilelist_icase(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_vector filelist; git_tree *tree; 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"); git_repository_head_tree(&tree, g_repo); 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_tree(&i, tree, &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_tree(&i, tree, &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_tree(&i, tree, &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_tree(&i, tree, &i_opts)); expect_iterator_items(i, 2, NULL, 2, NULL); git_iterator_free(i); git_vector_free(&filelist); git_tree_free(tree); }
void test_repo_iterator__treefilelist(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_vector filelist; git_tree *tree; 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"); git_repository_head_tree(&tree, g_repo); /* 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_tree(&i, tree, &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_tree(&i, tree, &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_tree(&i, tree, &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); git_tree_free(tree); }
void test_repo_iterator__indexfilelist(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_index *index; git_vector filelist; int 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/1")); cl_git_pass(git_vector_insert(&filelist, "k/a")); cl_git_pass(git_vector_insert(&filelist, "L/1")); g_repo = cl_git_sandbox_init("icase"); cl_git_pass(git_repository_index(&index, g_repo)); /* In this test we DO NOT force a case setting on the index. */ default_icase = ((git_index_caps(index) & GIT_INDEXCAP_IGNORE_CASE) != 0); i_opts.pathlist.strings = (char **)filelist.contents; i_opts.pathlist.count = filelist.length; /* All indexfilelist iterator tests are "autoexpand with no tree entries" */ cl_git_pass(git_iterator_for_index(&i, index, &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_index(&i, index, &i_opts)); /* (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_index(&i, index, &i_opts)); /* (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_index_free(index); git_vector_free(&filelist); }
void test_repo_iterator__tree_case_conflicts_1(void) { const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6"; git_tree *tree; git_oid blob_id, Ab_id, biga_id, littlea_id, tree_id; git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; const char *expect_cs[] = { "A/a", "A/b/1", "A/c", "a/C", "a/a", "a/b" }; const char *expect_ci[] = { "A/a", "a/b", "A/b/1", "A/c" }; const char *expect_cs_trees[] = { "A/", "A/a", "A/b/", "A/b/1", "A/c", "a/", "a/C", "a/a", "a/b" }; const char *expect_ci_trees[] = { "A/", "A/a", "a/b", "A/b/", "A/b/1", "A/c" }; g_repo = cl_git_sandbox_init("icase"); cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */ /* create: A/a A/b/1 A/c a/a a/b a/C */ build_test_tree(&Ab_id, g_repo, "b|1|", &blob_id); build_test_tree( &biga_id, g_repo, "b|a|,t|b|,b|c|", &blob_id, &Ab_id, &blob_id); build_test_tree( &littlea_id, g_repo, "b|a|,b|b|,b|C|", &blob_id, &blob_id, &blob_id); build_test_tree( &tree_id, g_repo, "t|A|,t|a|", &biga_id, &littlea_id); cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id)); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 6, expect_cs, 6, expect_cs); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_IGNORE_CASE; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 4, expect_ci, 4, expect_ci); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 9, expect_cs_trees, 9, expect_cs_trees); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 6, expect_ci_trees, 6, expect_ci_trees); git_iterator_free(i); git_tree_free(tree); }
void test_repo_iterator__tree_case_conflicts_0(void) { const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6"; git_tree *tree; git_oid blob_id, biga_id, littlea_id, tree_id; git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; const char *expect_cs[] = { "A/1.file", "A/3.file", "a/2.file", "a/4.file" }; const char *expect_ci[] = { "A/1.file", "a/2.file", "A/3.file", "a/4.file" }; const char *expect_cs_trees[] = { "A/", "A/1.file", "A/3.file", "a/", "a/2.file", "a/4.file" }; const char *expect_ci_trees[] = { "A/", "A/1.file", "a/2.file", "A/3.file", "a/4.file" }; g_repo = cl_git_sandbox_init("icase"); cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */ /* create tree with: A/1.file, A/3.file, a/2.file, a/4.file */ build_test_tree( &biga_id, g_repo, "b|1.file|,b|3.file|", &blob_id, &blob_id); build_test_tree( &littlea_id, g_repo, "b|2.file|,b|4.file|", &blob_id, &blob_id); build_test_tree( &tree_id, g_repo, "t|A|,t|a|", &biga_id, &littlea_id); cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id)); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 4, expect_cs, 4, expect_cs); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_IGNORE_CASE; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 4, expect_ci, 4, expect_ci); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 6, expect_cs_trees, 6, expect_cs_trees); git_iterator_free(i); i_opts.flags = GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_INCLUDE_TREES; cl_git_pass(git_iterator_for_tree(&i, tree, &i_opts)); expect_iterator_items(i, 5, expect_ci_trees, 5, expect_ci_trees); git_iterator_free(i); git_tree_free(tree); }
static void check_tree_range( git_repository *repo, const char *start, const char *end, bool ignore_case, int expected_count) { git_tree *head; git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; int error, count; i_opts.flags = ignore_case ? GIT_ITERATOR_IGNORE_CASE : GIT_ITERATOR_DONT_IGNORE_CASE; i_opts.start = start; i_opts.end = end; cl_git_pass(git_repository_head_tree(&head, repo)); cl_git_pass(git_iterator_for_tree(&i, head, &i_opts)); for (count = 0; !(error = git_iterator_advance(NULL, i)); ++count) /* count em up */; cl_assert_equal_i(GIT_ITEROVER, error); cl_assert_equal_i(expected_count, count); git_iterator_free(i); git_tree_free(head); }
void test_repo_iterator__unreadable_dir(void) { git_iterator *i; const git_index_entry *e; if (!cl_is_chmod_supported()) return; 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/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_git_fail(git_iterator_advance(&e, i)); /* b */ cl_assert_equal_i(GIT_ITEROVER, git_iterator_advance(&e, i)); cl_must_pass(p_chmod("empty_standard_repo/r/b", 0777)); git_iterator_free(i); }
static void tree_iterator_test( const char *sandbox, const char *treeish, const char *start, const char *end, int expected_count, const char **expected_values) { git_tree *t; git_iterator *i; const git_index_entry *entry; int count = 0; git_repository *repo = cl_git_sandbox_init(sandbox); cl_assert(t = resolve_commit_oid_to_tree(repo, treeish)); cl_git_pass(git_iterator_for_tree_range(&i, repo, t, start, end)); cl_git_pass(git_iterator_current(i, &entry)); while (entry != NULL) { if (expected_values != NULL) cl_assert_equal_s(expected_values[count], entry->path); count++; cl_git_pass(git_iterator_advance(i, &entry)); } git_iterator_free(i); cl_assert(expected_count == count); git_tree_free(t); }
static void index_iterator_test( const char *sandbox, const char *start, const char *end, int expected_count, const char **expected_names, const char **expected_oids) { git_iterator *i; const git_index_entry *entry; int count = 0; git_repository *repo = cl_git_sandbox_init(sandbox); cl_git_pass(git_iterator_for_index_range(&i, repo, start, end)); cl_git_pass(git_iterator_current(i, &entry)); while (entry != NULL) { if (expected_names != NULL) cl_assert_equal_s(expected_names[count], entry->path); if (expected_oids != NULL) { git_oid oid; cl_git_pass(git_oid_fromstr(&oid, expected_oids[count])); cl_assert_equal_i(git_oid_cmp(&oid, &entry->oid), 0); } count++; cl_git_pass(git_iterator_advance(i, &entry)); } git_iterator_free(i); cl_assert_equal_i(expected_count, count); }
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 git_note_iterator_free(git_note_iterator *it) { if (it == NULL) return; git_iterator_free(it); }
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_repo_iterator__skips_fifos_and_such(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 }
static void check_index_range( git_repository *repo, const char *start, const char *end, bool ignore_case, int expected_count) { git_index *index; git_iterator *i; int error, count, caps; bool is_ignoring_case; cl_git_pass(git_repository_index(&index, repo)); caps = git_index_caps(index); is_ignoring_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0); if (ignore_case != is_ignoring_case) cl_git_pass(git_index_set_caps(index, caps ^ GIT_INDEXCAP_IGNORE_CASE)); cl_git_pass(git_iterator_for_index(&i, index, 0, start, end)); cl_assert(git_iterator_ignore_case(i) == ignore_case); for (count = 0; !(error = git_iterator_advance(NULL, i)); ++count) /* count em up */; cl_assert_equal_i(GIT_ITEROVER, error); cl_assert_equal_i(expected_count, count); git_iterator_free(i); git_index_free(index); }
/* 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, 15, NULL, 15, NULL); git_iterator_free(i); git_buf_dispose(&parent); }
void test_iterator_workdir__filesystem2(void) { git_iterator *i; static const char *expect_base[] = { "heads/br2", "heads/dir", "heads/executable", "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, 16, expect_base, 16, expect_base); git_iterator_free(i); }
int git_note_foreach( git_repository *repo, const char *notes_ref, git_note_foreach_cb note_cb, void *payload) { int error; git_iterator *iter = NULL; git_tree *tree = NULL; git_commit *commit = NULL; const git_index_entry *item; if (!(error = retrieve_note_tree_and_commit( &tree, &commit, repo, ¬es_ref)) && !(error = git_iterator_for_tree(&iter, tree))) error = git_iterator_current(iter, &item); while (!error && item) { error = process_entry_path(item->path, &item->oid, note_cb, payload); if (!error) error = git_iterator_advance(iter, &item); } git_iterator_free(iter); git_tree_free(tree); git_commit_free(commit); return error; }
static int submodules_from_index(git_strmap *map, git_index *idx) { int error; git_iterator *i; const git_index_entry *entry; if ((error = git_iterator_for_index(&i, idx, 0, NULL, NULL)) < 0) return error; while (!(error = git_iterator_advance(&entry, i))) { khiter_t pos = git_strmap_lookup_index(map, entry->path); git_submodule *sm; if (git_strmap_valid_index(map, pos)) { sm = git_strmap_value_at(map, pos); if (S_ISGITLINK(entry->mode)) submodule_update_from_index_entry(sm, entry); else sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE; } else if (S_ISGITLINK(entry->mode)) { if (!submodule_get_or_create(&sm, git_index_owner(idx), map, entry->path)) { submodule_update_from_index_entry(sm, entry); git_submodule_free(sm); } } } if (error == GIT_ITEROVER) error = 0; git_iterator_free(i); return error; }
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_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_diff_iterator__tree_special_functions(void) { git_tree *t; git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; const git_index_entry *entry; git_repository *repo = cl_git_sandbox_init("attr"); int error, cases = 0; const char *rootoid = "ce39a97a7fb1fa90bcf5e711249c1e507476ae0e"; t = resolve_commit_oid_to_tree( repo, "24fa9a9fc4e202313e24b648087495441dab432b"); cl_assert(t != NULL); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE; cl_git_pass(git_iterator_for_tree(&i, t, &i_opts)); while (!(error = git_iterator_advance(&entry, i))) { cl_assert(entry); if (strcmp(entry->path, "sub/file") == 0) { cases++; check_tree_entry( i, "45b983be36b73c0788dc9cbcb76cbb80fc7bb057", "ecb97df2a174987475ac816e3847fc8e9f6c596b", rootoid, NULL); } else if (strcmp(entry->path, "sub/sub/subsub.txt") == 0) { cases++; check_tree_entry( i, "9e5bdc47d6a80f2be0ea3049ad74231b94609242", "4e49ba8c5b6c32ff28cd9dcb60be34df50fcc485", "ecb97df2a174987475ac816e3847fc8e9f6c596b", rootoid); } else if (strcmp(entry->path, "subdir/.gitattributes") == 0) { cases++; check_tree_entry( i, "99eae476896f4907224978b88e5ecaa6c5bb67a9", "9fb40b6675dde60b5697afceae91b66d908c02d9", rootoid, NULL); } else if (strcmp(entry->path, "subdir2/subdir2_test1") == 0) { cases++; check_tree_entry( i, "dccada462d3df8ac6de596fb8c896aba9344f941", "2929de282ce999e95183aedac6451d3384559c4b", rootoid, NULL); } } cl_assert_equal_i(GIT_ITEROVER, error); cl_assert(!entry); cl_assert_equal_i(4, cases); git_iterator_free(i); git_tree_free(t); }
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); }
static void index_iterator_test( const char *sandbox, const char *start, const char *end, git_iterator_flag_t flags, int expected_count, const char **expected_names, const char **expected_oids) { git_index *index; git_iterator *i; const git_index_entry *entry; int error, count = 0, caps; git_repository *repo = cl_git_sandbox_init(sandbox); git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT; cl_git_pass(git_repository_index(&index, repo)); caps = git_index_caps(index); iter_opts.flags = flags; iter_opts.start = start; iter_opts.end = end; cl_git_pass(git_iterator_for_index(&i, repo, index, &iter_opts)); while (!(error = git_iterator_advance(&entry, i))) { cl_assert(entry); if (expected_names != NULL) cl_assert_equal_s(expected_names[count], entry->path); if (expected_oids != NULL) { git_oid oid; cl_git_pass(git_oid_fromstr(&oid, expected_oids[count])); cl_assert_equal_oid(&oid, &entry->id); } count++; } cl_assert_equal_i(GIT_ITEROVER, error); cl_assert(!entry); cl_assert_equal_i(expected_count, count); git_iterator_free(i); cl_assert(caps == git_index_caps(index)); git_index_free(index); }
static void tree_iterator_test( const char *sandbox, const char *treeish, const char *start, const char *end, int expected_count, const char **expected_values) { git_tree *t; git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; const git_index_entry *entry; int error, count = 0, count_post_reset = 0; git_repository *repo = cl_git_sandbox_init(sandbox); i_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE; i_opts.start = start; i_opts.end = end; cl_assert(t = resolve_commit_oid_to_tree(repo, treeish)); cl_git_pass(git_iterator_for_tree(&i, t, &i_opts)); /* test loop */ while (!(error = git_iterator_advance(&entry, i))) { cl_assert(entry); if (expected_values != NULL) cl_assert_equal_s(expected_values[count], entry->path); count++; } cl_assert_equal_i(GIT_ITEROVER, error); cl_assert(!entry); cl_assert_equal_i(expected_count, count); /* test reset */ cl_git_pass(git_iterator_reset(i, NULL, NULL)); while (!(error = git_iterator_advance(&entry, i))) { cl_assert(entry); if (expected_values != NULL) cl_assert_equal_s(expected_values[count_post_reset], entry->path); count_post_reset++; } cl_assert_equal_i(GIT_ITEROVER, error); cl_assert(!entry); cl_assert_equal_i(count, count_post_reset); git_iterator_free(i); git_tree_free(t); }
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; const git_index_entry *entry; int count = 0, count_all = 0; git_repository *repo = cl_git_sandbox_init(sandbox); cl_git_pass(git_iterator_for_workdir_range(&i, repo, start, end)); cl_git_pass(git_iterator_current(i, &entry)); while (entry != NULL) { int ignored = git_iterator_current_is_ignored(i); if (S_ISDIR(entry->mode)) { cl_git_pass(git_iterator_advance_into_directory(i, &entry)); 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++; cl_git_pass(git_iterator_advance(i, &entry)); } git_iterator_free(i); cl_assert_equal_i(expected_count,count); cl_assert_equal_i(expected_count + expected_ignores, count_all); }
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_repo_iterator__indexfilelist_4(void) { git_iterator *i; git_iterator_options i_opts = GIT_ITERATOR_OPTIONS_INIT; git_index *index; git_vector filelist = GIT_VECTOR_INIT; int default_icase, expect; g_repo = cl_git_sandbox_init("icase"); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_vector_init(&filelist, 100, &git__strcmp_cb)); cl_git_pass(git_vector_insert(&filelist, "0")); 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")); 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, "kZZZZZZZ")); /* In this test we DO NOT force a case setting on the index. */ default_icase = ((git_index_caps(index) & GIT_INDEXCAP_IGNORE_CASE) != 0); i_opts.pathlist.strings = (char **)filelist.contents; i_opts.pathlist.count = filelist.length; i_opts.start = "b"; i_opts.end = "k/D"; /* (c D e k/1 k/a k/B k/c k/D) vs (c e k/1 k/B k/D) */ expect = default_icase ? 8 : 5; cl_git_pass(git_iterator_for_index(&i, index, &i_opts)); expect_iterator_items(i, expect, NULL, expect, NULL); git_iterator_free(i); git_index_free(index); git_vector_free(&filelist); }