mirror of
https://git.proxmox.com/git/libgit2
synced 2025-05-05 18:44:31 +00:00
a5eea2d7b7
Given a group of case-insensitively equivalent tree iterator entries, this ensures that the case-sensitively first trees will be used as the representative items. I.e. if you have conflicting entries "A/B/x", "a/b/x", and "A/b/x", this change ensures that the earliest entry "A/B/x" will be returned. The actual choice is not that important, but it is nice to have it stable and to have it been either the first or last item, as opposed to a random item from within the equivalent span.
748 lines
23 KiB
C
748 lines
23 KiB
C
#include "clar_libgit2.h"
|
|
#include "iterator.h"
|
|
#include "repository.h"
|
|
#include <stdarg.h>
|
|
|
|
static git_repository *g_repo;
|
|
|
|
void test_repo_iterator__initialize(void)
|
|
{
|
|
}
|
|
|
|
void test_repo_iterator__cleanup(void)
|
|
{
|
|
cl_git_sandbox_cleanup();
|
|
g_repo = NULL;
|
|
}
|
|
|
|
static void expect_iterator_items(
|
|
git_iterator *i,
|
|
int expected_flat,
|
|
const char **expected_flat_paths,
|
|
int expected_total,
|
|
const char **expected_total_paths)
|
|
{
|
|
const git_index_entry *entry;
|
|
int count;
|
|
int no_trees = !(git_iterator_flags(i) & GIT_ITERATOR_INCLUDE_TREES);
|
|
bool v = false;
|
|
|
|
if (expected_flat < 0) { v = true; expected_flat = -expected_flat; }
|
|
if (expected_total < 0) { v = true; expected_total = -expected_total; }
|
|
|
|
count = 0;
|
|
cl_git_pass(git_iterator_current(&entry, i));
|
|
|
|
if (v) fprintf(stderr, "== %s ==\n", no_trees ? "notrees" : "trees");
|
|
|
|
while (entry != NULL) {
|
|
if (v) fprintf(stderr, " %s %07o\n", entry->path, (int)entry->mode);
|
|
|
|
if (no_trees)
|
|
cl_assert(entry->mode != GIT_FILEMODE_TREE);
|
|
|
|
if (expected_flat_paths) {
|
|
const char *expect_path = expected_flat_paths[count];
|
|
size_t expect_len = strlen(expect_path);
|
|
|
|
cl_assert_equal_s(expect_path, entry->path);
|
|
|
|
if (expect_path[expect_len - 1] == '/')
|
|
cl_assert_equal_i(GIT_FILEMODE_TREE, entry->mode);
|
|
else
|
|
cl_assert(entry->mode != GIT_FILEMODE_TREE);
|
|
}
|
|
|
|
cl_git_pass(git_iterator_advance(&entry, i));
|
|
|
|
if (++count > expected_flat)
|
|
break;
|
|
}
|
|
|
|
cl_assert_equal_i(expected_flat, count);
|
|
|
|
cl_git_pass(git_iterator_reset(i, NULL, NULL));
|
|
|
|
count = 0;
|
|
cl_git_pass(git_iterator_current(&entry, i));
|
|
|
|
if (v) fprintf(stderr, "-- %s --\n", no_trees ? "notrees" : "trees");
|
|
|
|
while (entry != NULL) {
|
|
if (v) fprintf(stderr, " %s %07o\n", entry->path, (int)entry->mode);
|
|
|
|
if (no_trees)
|
|
cl_assert(entry->mode != GIT_FILEMODE_TREE);
|
|
|
|
if (expected_total_paths) {
|
|
const char *expect_path = expected_total_paths[count];
|
|
size_t expect_len = strlen(expect_path);
|
|
|
|
cl_assert_equal_s(expect_path, entry->path);
|
|
|
|
if (expect_path[expect_len - 1] == '/')
|
|
cl_assert_equal_i(GIT_FILEMODE_TREE, entry->mode);
|
|
else
|
|
cl_assert(entry->mode != GIT_FILEMODE_TREE);
|
|
}
|
|
|
|
if (entry->mode == GIT_FILEMODE_TREE)
|
|
cl_git_pass(git_iterator_advance_into(&entry, i));
|
|
else
|
|
cl_git_pass(git_iterator_advance(&entry, i));
|
|
|
|
if (++count > expected_total)
|
|
break;
|
|
}
|
|
|
|
cl_assert_equal_i(expected_total, count);
|
|
}
|
|
|
|
/* Index contents (including pseudotrees):
|
|
*
|
|
* 0: a 5: F 10: k/ 16: L/
|
|
* 1: B 6: g 11: k/1 17: L/1
|
|
* 2: c 7: H 12: k/a 18: L/a
|
|
* 3: D 8: i 13: k/B 19: L/B
|
|
* 4: e 9: J 14: k/c 20: L/c
|
|
* 15: k/D 21: L/D
|
|
*
|
|
* 0: B 5: L/ 11: a 16: k/
|
|
* 1: D 6: L/1 12: c 17: k/1
|
|
* 2: F 7: L/B 13: e 18: k/B
|
|
* 3: H 8: L/D 14: g 19: k/D
|
|
* 4: J 9: L/a 15: i 20: k/a
|
|
* 10: L/c 21: k/c
|
|
*/
|
|
|
|
void test_repo_iterator__index(void)
|
|
{
|
|
git_iterator *i;
|
|
git_index *index;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
cl_git_pass(git_repository_index(&index, g_repo));
|
|
|
|
/* autoexpand with no tree entries for index */
|
|
cl_git_pass(git_iterator_for_index(&i, index, 0, NULL, NULL));
|
|
expect_iterator_items(i, 20, NULL, 20, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 22, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
|
|
expect_iterator_items(i, 12, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
git_index_free(index);
|
|
}
|
|
|
|
void test_repo_iterator__index_icase(void)
|
|
{
|
|
git_iterator *i;
|
|
git_index *index;
|
|
unsigned int caps;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
cl_git_pass(git_repository_index(&index, g_repo));
|
|
caps = git_index_caps(index);
|
|
|
|
/* force case sensitivity */
|
|
cl_git_pass(git_index_set_caps(index, caps & ~GIT_INDEXCAP_IGNORE_CASE));
|
|
|
|
/* autoexpand with no tree entries over range */
|
|
cl_git_pass(git_iterator_for_index(&i, index, 0, "c", "k/D"));
|
|
expect_iterator_items(i, 7, NULL, 7, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_index(&i, index, 0, "k", "k/Z"));
|
|
expect_iterator_items(i, 3, NULL, 3, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 8, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 4, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 5, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* force case insensitivity */
|
|
cl_git_pass(git_index_set_caps(index, caps | GIT_INDEXCAP_IGNORE_CASE));
|
|
|
|
/* autoexpand with no tree entries over range */
|
|
cl_git_pass(git_iterator_for_index(&i, index, 0, "c", "k/D"));
|
|
expect_iterator_items(i, 13, NULL, 13, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_index(&i, index, 0, "k", "k/Z"));
|
|
expect_iterator_items(i, 5, NULL, 5, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 14, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 6, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 9, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_index(
|
|
&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_index_set_caps(index, caps));
|
|
git_index_free(index);
|
|
}
|
|
|
|
void test_repo_iterator__tree(void)
|
|
{
|
|
git_iterator *i;
|
|
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, 0, NULL, NULL));
|
|
expect_iterator_items(i, 20, NULL, 20, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 22, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
|
|
expect_iterator_items(i, 12, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
git_tree_free(head);
|
|
}
|
|
|
|
void test_repo_iterator__tree_icase(void)
|
|
{
|
|
git_iterator *i;
|
|
git_tree *head;
|
|
git_iterator_flag_t flag;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
cl_git_pass(git_repository_head_tree(&head, g_repo));
|
|
|
|
flag = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_tree(&i, head, flag, "c", "k/D"));
|
|
expect_iterator_items(i, 7, NULL, 7, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(&i, head, flag, "k", "k/Z"));
|
|
expect_iterator_items(i, 3, NULL, 3, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 8, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 4, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 5, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
flag = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_tree(&i, head, flag, "c", "k/D"));
|
|
expect_iterator_items(i, 13, NULL, 13, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(&i, head, flag, "k", "k/Z"));
|
|
expect_iterator_items(i, 5, NULL, 5, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 14, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 6, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 9, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_repo_iterator__tree_more(void)
|
|
{
|
|
git_iterator *i;
|
|
git_tree *head;
|
|
static const char *expect_basic[] = {
|
|
"current_file",
|
|
"file_deleted",
|
|
"modified_file",
|
|
"staged_changes",
|
|
"staged_changes_file_deleted",
|
|
"staged_changes_modified_file",
|
|
"staged_delete_file_deleted",
|
|
"staged_delete_modified_file",
|
|
"subdir.txt",
|
|
"subdir/current_file",
|
|
"subdir/deleted_file",
|
|
"subdir/modified_file",
|
|
NULL,
|
|
};
|
|
static const char *expect_trees[] = {
|
|
"current_file",
|
|
"file_deleted",
|
|
"modified_file",
|
|
"staged_changes",
|
|
"staged_changes_file_deleted",
|
|
"staged_changes_modified_file",
|
|
"staged_delete_file_deleted",
|
|
"staged_delete_modified_file",
|
|
"subdir.txt",
|
|
"subdir/",
|
|
"subdir/current_file",
|
|
"subdir/deleted_file",
|
|
"subdir/modified_file",
|
|
NULL,
|
|
};
|
|
static const char *expect_noauto[] = {
|
|
"current_file",
|
|
"file_deleted",
|
|
"modified_file",
|
|
"staged_changes",
|
|
"staged_changes_file_deleted",
|
|
"staged_changes_modified_file",
|
|
"staged_delete_file_deleted",
|
|
"staged_delete_modified_file",
|
|
"subdir.txt",
|
|
"subdir/",
|
|
NULL
|
|
};
|
|
|
|
g_repo = cl_git_sandbox_init("status");
|
|
|
|
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, 0, NULL, NULL));
|
|
expect_iterator_items(i, 12, expect_basic, 12, expect_basic);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 13, expect_trees, 13, expect_trees);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, head, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
|
|
expect_iterator_items(i, 10, expect_noauto, 13, expect_trees);
|
|
git_iterator_free(i);
|
|
|
|
git_tree_free(head);
|
|
}
|
|
|
|
/* "b=name,t=name", blob_id, tree_id */
|
|
static void build_test_tree(
|
|
git_oid *out, git_repository *repo, const char *fmt, ...)
|
|
{
|
|
git_oid *id;
|
|
git_treebuilder *builder;
|
|
const char *scan = fmt, *next;
|
|
char type, delimiter;
|
|
git_filemode_t mode;
|
|
git_buf name = GIT_BUF_INIT;
|
|
va_list arglist;
|
|
|
|
cl_git_pass(git_treebuilder_create(&builder, NULL)); /* start builder */
|
|
|
|
va_start(arglist, fmt);
|
|
while (*scan) {
|
|
switch (type = *scan++) {
|
|
case 't': case 'T': mode = GIT_FILEMODE_TREE; break;
|
|
case 'b': case 'B': mode = GIT_FILEMODE_BLOB; break;
|
|
default:
|
|
cl_assert(type == 't' || type == 'T' || type == 'b' || type == 'B');
|
|
}
|
|
|
|
delimiter = *scan++; /* read and skip delimiter */
|
|
for (next = scan; *next && *next != delimiter; ++next)
|
|
/* seek end */;
|
|
cl_git_pass(git_buf_set(&name, scan, (size_t)(next - scan)));
|
|
for (scan = next; *scan && (*scan == delimiter || *scan == ','); ++scan)
|
|
/* skip delimiter and optional comma */;
|
|
|
|
id = va_arg(arglist, git_oid *);
|
|
|
|
cl_git_pass(git_treebuilder_insert(NULL, builder, name.ptr, id, mode));
|
|
}
|
|
va_end(arglist);
|
|
|
|
cl_git_pass(git_treebuilder_write(out, repo, builder));
|
|
|
|
git_treebuilder_free(builder);
|
|
git_buf_free(&name);
|
|
}
|
|
|
|
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;
|
|
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));
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 4, expect_cs, 4, expect_cs);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 4, expect_ci, 4, expect_ci);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE |
|
|
GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 6, expect_cs_trees, 6, expect_cs_trees);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE |
|
|
GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 5, expect_ci_trees, 5, expect_ci_trees);
|
|
git_iterator_free(i);
|
|
|
|
git_tree_free(tree);
|
|
}
|
|
|
|
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;
|
|
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));
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 6, expect_cs, 6, expect_cs);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 4, expect_ci, 4, expect_ci);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE |
|
|
GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 9, expect_cs_trees, 9, expect_cs_trees);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE |
|
|
GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
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_2(void)
|
|
{
|
|
const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6";
|
|
git_tree *tree;
|
|
git_oid blob_id, d1, d2, c1, c2, b1, b2, a1, a2, tree_id;
|
|
git_iterator *i;
|
|
const char *expect_cs[] = {
|
|
"A/B/C/D/16", "A/B/C/D/foo", "A/B/C/d/15", "A/B/C/d/FOO",
|
|
"A/B/c/D/14", "A/B/c/D/foo", "A/B/c/d/13", "A/B/c/d/FOO",
|
|
"A/b/C/D/12", "A/b/C/D/foo", "A/b/C/d/11", "A/b/C/d/FOO",
|
|
"A/b/c/D/10", "A/b/c/D/foo", "A/b/c/d/09", "A/b/c/d/FOO",
|
|
"a/B/C/D/08", "a/B/C/D/foo", "a/B/C/d/07", "a/B/C/d/FOO",
|
|
"a/B/c/D/06", "a/B/c/D/foo", "a/B/c/d/05", "a/B/c/d/FOO",
|
|
"a/b/C/D/04", "a/b/C/D/foo", "a/b/C/d/03", "a/b/C/d/FOO",
|
|
"a/b/c/D/02", "a/b/c/D/foo", "a/b/c/d/01", "a/b/c/d/FOO", };
|
|
const char *expect_ci[] = {
|
|
"a/b/c/d/01", "a/b/c/D/02", "a/b/C/d/03", "a/b/C/D/04",
|
|
"a/B/c/d/05", "a/B/c/D/06", "a/B/C/d/07", "a/B/C/D/08",
|
|
"A/b/c/d/09", "A/b/c/D/10", "A/b/C/d/11", "A/b/C/D/12",
|
|
"A/B/c/d/13", "A/B/c/D/14", "A/B/C/d/15", "A/B/C/D/16",
|
|
"A/B/C/D/foo", };
|
|
const char *expect_ci_trees[] = {
|
|
"A/", "A/B/", "A/B/C/", "A/B/C/D/",
|
|
"a/b/c/d/01", "a/b/c/D/02", "a/b/C/d/03", "a/b/C/D/04",
|
|
"a/B/c/d/05", "a/B/c/D/06", "a/B/C/d/07", "a/B/C/D/08",
|
|
"A/b/c/d/09", "A/b/c/D/10", "A/b/C/d/11", "A/b/C/D/12",
|
|
"A/B/c/d/13", "A/B/c/D/14", "A/B/C/d/15", "A/B/C/D/16",
|
|
"A/B/C/D/foo", };
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */
|
|
|
|
build_test_tree(&d1, g_repo, "b|16|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|15|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&d1, g_repo, "b|14|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|13|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&b1, g_repo, "t|C|,t|c|", &c1, &c2);
|
|
|
|
build_test_tree(&d1, g_repo, "b|12|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|11|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&d1, g_repo, "b|10|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|09|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&b2, g_repo, "t|C|,t|c|", &c1, &c2);
|
|
|
|
build_test_tree(&a1, g_repo, "t|B|,t|b|", &b1, &b2);
|
|
|
|
build_test_tree(&d1, g_repo, "b|08|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|07|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&d1, g_repo, "b|06|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|05|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&b1, g_repo, "t|C|,t|c|", &c1, &c2);
|
|
|
|
build_test_tree(&d1, g_repo, "b|04|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|03|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&d1, g_repo, "b|02|,b|foo|", &blob_id, &blob_id);
|
|
build_test_tree(&d2, g_repo, "b|01|,b|FOO|", &blob_id, &blob_id);
|
|
build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
|
|
build_test_tree(&b2, g_repo, "t|C|,t|c|", &c1, &c2);
|
|
|
|
build_test_tree(&a2, g_repo, "t|B|,t|b|", &b1, &b2);
|
|
|
|
build_test_tree(&tree_id, g_repo, "t/A/,t/a/", &a1, &a2);
|
|
|
|
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 32, expect_cs, 32, expect_cs);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
|
|
expect_iterator_items(i, 17, expect_ci, 17, expect_ci);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_tree(
|
|
&i, tree, GIT_ITERATOR_IGNORE_CASE |
|
|
GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 21, expect_ci_trees, 21, expect_ci_trees);
|
|
git_iterator_free(i);
|
|
|
|
git_tree_free(tree);
|
|
}
|
|
|
|
void test_repo_iterator__workdir(void)
|
|
{
|
|
git_iterator *i;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, 0, NULL, NULL));
|
|
expect_iterator_items(i, 20, NULL, 20, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
|
|
expect_iterator_items(i, 22, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
|
|
expect_iterator_items(i, 12, NULL, 22, NULL);
|
|
git_iterator_free(i);
|
|
}
|
|
|
|
void test_repo_iterator__workdir_icase(void)
|
|
{
|
|
git_iterator *i;
|
|
git_iterator_flag_t flag;
|
|
|
|
g_repo = cl_git_sandbox_init("icase");
|
|
|
|
flag = GIT_ITERATOR_DONT_IGNORE_CASE;
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "c", "k/D"));
|
|
expect_iterator_items(i, 7, NULL, 7, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "k", "k/Z"));
|
|
expect_iterator_items(i, 3, NULL, 3, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 8, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 4, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 5, NULL, 8, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 4, NULL);
|
|
git_iterator_free(i);
|
|
|
|
flag = GIT_ITERATOR_IGNORE_CASE;
|
|
|
|
/* auto expand with no tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "c", "k/D"));
|
|
expect_iterator_items(i, 13, NULL, 13, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "k", "k/Z"));
|
|
expect_iterator_items(i, 5, NULL, 5, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* auto expand with tree entries */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
|
|
expect_iterator_items(i, 14, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
|
|
expect_iterator_items(i, 6, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
|
|
/* no auto expand (implies trees included) */
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
|
|
expect_iterator_items(i, 9, NULL, 14, NULL);
|
|
git_iterator_free(i);
|
|
|
|
cl_git_pass(git_iterator_for_workdir(
|
|
&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
|
|
expect_iterator_items(i, 1, NULL, 6, NULL);
|
|
git_iterator_free(i);
|
|
}
|