void test_object_tree_update__remove_all_entries(void) { git_oid tree_index_id, tree_updater_id, base_id; git_tree *base_tree; git_index *idx; const char *path1 = "subdir/subdir2/README"; const char *path2 = "subdir/subdir2/new.txt"; git_tree_update updates[] = { { GIT_TREE_UPDATE_REMOVE, {{0}}, GIT_FILEMODE_BLOB /* ignored */, path1}, { GIT_TREE_UPDATE_REMOVE, {{0}}, GIT_FILEMODE_BLOB /* ignored */, path2}, }; cl_git_pass(git_oid_fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b")); cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ cl_git_pass(git_index_new(&idx)); cl_git_pass(git_index_read_tree(idx, base_tree)); cl_git_pass(git_index_remove(idx, path1, 0)); cl_git_pass(git_index_remove(idx, path2, 0)); cl_git_pass(git_index_write_tree_to(&tree_index_id, idx, g_repo)); git_index_free(idx); /* Perform the same operation via the tree updater */ cl_git_pass(git_tree_create_updated(&tree_updater_id, g_repo, base_tree, 2, updates)); cl_assert_equal_oid(&tree_index_id, &tree_updater_id); git_tree_free(base_tree); }
void test_diff_index__to_index(void) { const char *a_commit = "26a125ee1bf"; /* the current HEAD */ git_tree *old_tree; git_index *old_index; git_index *new_index; git_diff *diff; diff_expects exp; cl_git_pass(git_index_new(&old_index)); old_tree = resolve_commit_oid_to_tree(g_repo, a_commit); cl_git_pass(git_index_read_tree(old_index, old_tree)); cl_git_pass(git_repository_index(&new_index, g_repo)); cl_git_pass(git_diff_index_to_index(&diff, g_repo, old_index, new_index, NULL)); memset(&exp, 0, sizeof(diff_expects)); cl_git_pass(git_diff_foreach( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp)); cl_assert_equal_i(8, exp.files); cl_assert_equal_i(3, exp.file_status[GIT_DELTA_ADDED]); cl_assert_equal_i(2, exp.file_status[GIT_DELTA_DELETED]); cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]); cl_assert_equal_i(0, exp.file_status[GIT_DELTA_CONFLICTED]); git_diff_free(diff); git_index_free(new_index); git_index_free(old_index); git_tree_free(old_tree); }
void test_object_tree_update__replace_blob(void) { git_oid tree_index_id, tree_updater_id, base_id; git_tree *base_tree; git_index *idx; const char *path = "README"; git_index_entry entry = { {0} }; git_tree_update updates[] = { { GIT_TREE_UPDATE_UPSERT, {{0}}, GIT_FILEMODE_BLOB, path}, }; cl_git_pass(git_oid_fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b")); cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); /* Create it with an index */ cl_git_pass(git_index_new(&idx)); cl_git_pass(git_index_read_tree(idx, base_tree)); entry.path = path; cl_git_pass(git_oid_fromstr(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92")); entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_index_add(idx, &entry)); cl_git_pass(git_index_write_tree_to(&tree_index_id, idx, g_repo)); git_index_free(idx); /* Perform the same operation via the tree updater */ cl_git_pass(git_oid_fromstr(&updates[0].id, "fa49b077972391ad58037050f2a75f74e3671e92")); cl_git_pass(git_tree_create_updated(&tree_updater_id, g_repo, base_tree, 1, updates)); cl_assert_equal_oid(&tree_index_id, &tree_updater_id); git_tree_free(base_tree); }
void test_index_inmemory__can_create_an_inmemory_index(void) { git_index *index; cl_git_pass(git_index_new(&index)); cl_assert_equal_i(0, (int)git_index_entrycount(index)); git_index_free(index); }
void test_object_tree_update__add_blobs(void) { git_oid tree_index_id, tree_updater_id, base_id; git_tree *base_tree; git_index *idx; git_index_entry entry = { {0} }; int i; const char *paths[] = { "some/deep/path", "some/other/path", "a/path/elsewhere", }; git_tree_update updates[] = { { GIT_TREE_UPDATE_UPSERT, {{0}}, GIT_FILEMODE_BLOB, paths[0]}, { GIT_TREE_UPDATE_UPSERT, {{0}}, GIT_FILEMODE_BLOB, paths[1]}, { GIT_TREE_UPDATE_UPSERT, {{0}}, GIT_FILEMODE_BLOB, paths[2]}, }; cl_git_pass(git_oid_fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b")); entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_oid_fromstr(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92")); for (i = 0; i < 3; i++) { cl_git_pass(git_oid_fromstr(&updates[i].id, "fa49b077972391ad58037050f2a75f74e3671e92")); } for (i = 0; i < 2; i++) { int j; /* Create it with an index */ cl_git_pass(git_index_new(&idx)); base_tree = NULL; if (i == 1) { cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id)); cl_git_pass(git_index_read_tree(idx, base_tree)); } for (j = 0; j < 3; j++) { entry.path = paths[j]; cl_git_pass(git_index_add(idx, &entry)); } cl_git_pass(git_index_write_tree_to(&tree_index_id, idx, g_repo)); git_index_free(idx); /* Perform the same operations via the tree updater */ cl_git_pass(git_tree_create_updated(&tree_updater_id, g_repo, base_tree, 3, updates)); cl_assert_equal_oid(&tree_index_id, &tree_updater_id); } git_tree_free(base_tree); }
void test_index_inmemory__cannot_add_bypath_to_an_inmemory_index(void) { git_index *index; cl_git_pass(git_index_new(&index)); cl_assert_equal_i(GIT_ERROR, git_index_add_bypath(index, "test.txt")); git_index_free(index); }
void test_submodule_lookup__lookup_even_with_missing_index(void) { git_index *idx; /* give the repo an empty index */ cl_git_pass(git_index_new(&idx)); git_repository_set_index(g_repo, idx); git_index_free(idx); test_submodule_lookup__simple_lookup(); /* baseline should still pass */ }
void test_index_read_index__maintains_stat_cache(void) { git_index *new_index; git_oid index_id; git_index_entry new_entry; const git_index_entry *e; git_tree *tree; size_t i; cl_assert_equal_i(4, git_index_entrycount(_index)); /* write-tree */ cl_git_pass(git_index_write_tree(&index_id, _index)); /* read-tree, then read index */ git_tree_lookup(&tree, _repo, &index_id); cl_git_pass(git_index_new(&new_index)); cl_git_pass(git_index_read_tree(new_index, tree)); git_tree_free(tree); /* add a new entry that will not have stat data */ memset(&new_entry, 0, sizeof(git_index_entry)); new_entry.path = "Hello"; git_oid_fromstr(&new_entry.id, "0123456789012345678901234567890123456789"); new_entry.file_size = 1234; new_entry.mode = 0100644; cl_git_pass(git_index_add(new_index, &new_entry)); cl_assert_equal_i(5, git_index_entrycount(new_index)); cl_git_pass(git_index_read_index(_index, new_index)); git_index_free(new_index); cl_assert_equal_i(5, git_index_entrycount(_index)); for (i = 0; i < git_index_entrycount(_index); i++) { e = git_index_get_byindex(_index, i); if (strcmp(e->path, "Hello") == 0) { cl_assert_equal_i(0, e->ctime.seconds); cl_assert_equal_i(0, e->mtime.seconds); } else { cl_assert(0 != e->ctime.seconds); cl_assert(0 != e->mtime.seconds); } } }
static bool roundtrip_with_read_index(const char *tree_idstr) { git_oid tree_id, new_tree_id; git_tree *tree; git_index *tree_index; cl_git_pass(git_oid_fromstr(&tree_id, tree_idstr)); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); cl_git_pass(git_index_new(&tree_index)); cl_git_pass(git_index_read_tree(tree_index, tree)); cl_git_pass(git_index_read_index(_index, tree_index)); cl_git_pass(git_index_write_tree(&new_tree_id, _index)); git_tree_free(tree); git_index_free(tree_index); return git_oid_equal(&tree_id, &new_tree_id); }
ERL_NIF_TERM geef_index_new(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { geef_index *index; ERL_NIF_TERM term; index = enif_alloc_resource(geef_index_type, sizeof(geef_index)); if (!index) return geef_oom(env); if (git_index_new(&index->index) < 0) return geef_error(env); term = enif_make_resource(env, index); enif_release_resource(index); return enif_make_tuple2(env, atoms.ok, term); }
void test_clone_nonetwork__clone_tag_to_tree(void) { git_repository *stage; git_index_entry entry; git_index *index; git_odb *odb; git_oid tree_id; git_tree *tree; git_reference *tag; git_tree_entry *tentry; const char *file_path = "some/deep/path.txt"; const char *file_content = "some content\n"; const char *tag_name = "refs/tags/tree-tag"; stage = cl_git_sandbox_init("testrepo.git"); cl_git_pass(git_repository_odb(&odb, stage)); cl_git_pass(git_index_new(&index)); memset(&entry, 0, sizeof(git_index_entry)); entry.path = file_path; entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_odb_write(&entry.id, odb, file_content, strlen(file_content), GIT_OBJ_BLOB)); cl_git_pass(git_index_add(index, &entry)); cl_git_pass(git_index_write_tree_to(&tree_id, index, stage)); cl_git_pass(git_reference_create(&tag, stage, tag_name, &tree_id, 0, NULL)); git_reference_free(tag); git_odb_free(odb); git_index_free(index); g_options.local = GIT_CLONE_NO_LOCAL; cl_git_pass(git_clone(&g_repo, cl_git_path_url(git_repository_path(stage)), "./foo", &g_options)); git_repository_free(stage); cl_git_pass(git_reference_lookup(&tag, g_repo, tag_name)); cl_git_pass(git_tree_lookup(&tree, g_repo, git_reference_target(tag))); git_reference_free(tag); cl_git_pass(git_tree_entry_bypath(&tentry, tree, file_path)); git_tree_entry_free(tentry); git_tree_free(tree); cl_fixture_cleanup("testrepo.git"); }
void test_checkout_index__adding_conflict_removes_stage_0(void) { git_index *new_index, *index; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; cl_git_pass(git_index_new(&new_index)); add_conflict(new_index, "new.txt"); cl_git_pass(git_checkout_index(g_repo, new_index, &opts)); cl_git_pass(git_repository_index(&index, g_repo)); cl_assert(git_index_get_bypath(index, "new.txt", 0) == NULL); cl_assert(git_index_get_bypath(index, "new.txt", 1) != NULL); cl_assert(git_index_get_bypath(index, "new.txt", 2) != NULL); cl_assert(git_index_get_bypath(index, "new.txt", 3) != NULL); git_index_free(index); git_index_free(new_index); }
void test_index_racy__read_index_smudges(void) { git_index *index, *newindex; const git_index_entry *entry; /* if we are reading an index into our new index, ensure that any * racy entries in the index that we're reading are smudged so that * we don't propagate their timestamps without further investigation. */ setup_race(); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_new(&newindex)); cl_git_pass(git_index_read_index(newindex, index)); cl_assert(entry = git_index_get_bypath(newindex, "A", 0)); cl_assert_equal_i(0, entry->file_size); git_index_free(index); git_index_free(newindex); }
void test_index_read_index__read_and_writes(void) { git_oid tree_id, new_tree_id; git_tree *tree; git_index *tree_index, *new_index; cl_git_pass(git_oid_fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12")); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); cl_git_pass(git_index_new(&tree_index)); cl_git_pass(git_index_read_tree(tree_index, tree)); cl_git_pass(git_index_read_index(_index, tree_index)); cl_git_pass(git_index_write(_index)); cl_git_pass(git_index_open(&new_index, git_index_path(_index))); cl_git_pass(git_index_write_tree_to(&new_tree_id, new_index, _repo)); cl_assert_equal_oid(&tree_id, &new_tree_id); git_tree_free(tree); git_index_free(tree_index); git_index_free(new_index); }
void test_index_racy__read_index_clears_uptodate_bit(void) { git_index *index, *newindex; const git_index_entry *entry; setup_uptodate_files(); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_new(&newindex)); cl_git_pass(git_index_read_index(newindex, index)); /* ensure that files brought in from the other index are not uptodate */ cl_assert((entry = git_index_get_bypath(newindex, "A", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(newindex, "B", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(newindex, "C", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); git_index_free(index); git_index_free(newindex); }
void test_index_read_index__handles_conflicts(void) { git_oid tree_id; git_tree *tree; git_index *index, *new_index; git_index_conflict_iterator *conflict_iterator; const git_index_entry *ancestor, *ours, *theirs; cl_git_pass(git_oid_fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12")); cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); cl_git_pass(git_index_new(&index)); cl_git_pass(git_index_new(&new_index)); cl_git_pass(git_index_read_tree(index, tree)); cl_git_pass(git_index_read_tree(new_index, tree)); /* put some conflicts in only the old side, these should be removed */ add_conflicts(index, "orig_side-1.txt"); add_conflicts(index, "orig_side-2.txt"); /* put some conflicts in both indexes, these should be unchanged */ add_conflicts(index, "both_sides-1.txt"); add_conflicts(new_index, "both_sides-1.txt"); add_conflicts(index, "both_sides-2.txt"); add_conflicts(new_index, "both_sides-2.txt"); /* put some conflicts in the new index, these should be added */ add_conflicts(new_index, "new_side-1.txt"); add_conflicts(new_index, "new_side-2.txt"); cl_git_pass(git_index_read_index(index, new_index)); cl_git_pass(git_index_conflict_iterator_new(&conflict_iterator, index)); cl_git_pass(git_index_conflict_next( &ancestor, &ours, &theirs, conflict_iterator)); cl_assert_equal_s("both_sides-1.txt", ancestor->path); cl_assert_equal_s("both_sides-1.txt", ours->path); cl_assert_equal_s("both_sides-1.txt", theirs->path); cl_git_pass(git_index_conflict_next( &ancestor, &ours, &theirs, conflict_iterator)); cl_assert_equal_s("both_sides-2.txt", ancestor->path); cl_assert_equal_s("both_sides-2.txt", ours->path); cl_assert_equal_s("both_sides-2.txt", theirs->path); cl_git_pass(git_index_conflict_next( &ancestor, &ours, &theirs, conflict_iterator)); cl_assert_equal_s("new_side-1.txt", ancestor->path); cl_assert_equal_s("new_side-1.txt", ours->path); cl_assert_equal_s("new_side-1.txt", theirs->path); cl_git_pass(git_index_conflict_next( &ancestor, &ours, &theirs, conflict_iterator)); cl_assert_equal_s("new_side-2.txt", ancestor->path); cl_assert_equal_s("new_side-2.txt", ours->path); cl_assert_equal_s("new_side-2.txt", theirs->path); cl_git_fail_with(GIT_ITEROVER, git_index_conflict_next( &ancestor, &ours, &theirs, conflict_iterator)); git_index_conflict_iterator_free(conflict_iterator); git_tree_free(tree); git_index_free(new_index); git_index_free(index); }