void test_index_racy__diff(void) { git_index *index; git_diff *diff; git_buf path = GIT_BUF_INIT; cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A")); cl_git_mkfile(path.ptr, "A"); /* Put 'A' into the index */ cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_add_bypath(index, "A")); cl_git_pass(git_index_write(index)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL)); cl_assert_equal_i(0, git_diff_num_deltas(diff)); git_diff_free(diff); /* Change its contents quickly, so we get the same timestamp */ cl_git_mkfile(path.ptr, "B"); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL)); cl_assert_equal_i(1, git_diff_num_deltas(diff)); git_index_free(index); git_diff_free(diff); git_buf_dispose(&path); }
static git_diff_parsed *diff_parsed_alloc(void) { git_diff_parsed *diff; if ((diff = git__calloc(1, sizeof(git_diff_parsed))) == NULL) return NULL; GIT_REFCOUNT_INC(diff); diff->base.type = GIT_DIFF_TYPE_PARSED; diff->base.strcomp = git__strcmp; diff->base.strncomp = git__strncmp; diff->base.pfxcomp = git__prefixcmp; diff->base.entrycomp = git_diff__entry_cmp; diff->base.patch_fn = git_patch_parsed_from_diff; diff->base.free_fn = diff_parsed_free; if (git_diff_init_options(&diff->base.opts, GIT_DIFF_OPTIONS_VERSION) < 0) { git__free(diff); return NULL; } diff->base.opts.flags &= ~GIT_DIFF_IGNORE_CASE; git_pool_init(&diff->base.pool, 1); if (git_vector_init(&diff->patches, 0, NULL) < 0 || git_vector_init(&diff->base.deltas, 0, git_diff_delta__cmp) < 0) { git_diff_free(&diff->base); return NULL; } git_vector_set_cmp(&diff->base.deltas, git_diff_delta__cmp); return diff; }
int main(int argc, char *argv[]) { git_libgit2_init(); git_repository *repo = NULL; git_diff *diff = NULL; const char *repo_path = "/home/nghia/.git_packages/cache/version-checker/.git"; fprintf(stdout, "Current working dir: %s\n", repo_path); int error = git_repository_open(&repo, repo_path); fprintf(stdout, "error: %d\n", error); error = git_diff_index_to_workdir(&diff, repo, NULL, NULL); fprintf(stdout, "error: %d\n", error); git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, color_printer, NULL); git_diff_free(diff); git_libgit2_shutdown(); return 0; // error = git_diff_index_to_workdir(&diff, repo, NULL, NULL); // struct opts o = { // GIT_DIFF_OPTIONS_INIT, GIT_DIFF_FIND_OPTIONS_INIT, // -1, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "." // }; // git_libgit2_init(); }
static void test_notify( char **searched_pathspecs, int pathspecs_count, notify_expected *expected_matched_pathspecs, int expected_diffed_files_count) { git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_diff *diff = NULL; diff_expects exp; g_repo = cl_git_sandbox_init("status"); opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.notify_cb = assert_called_notifications; opts.pathspec.strings = searched_pathspecs; opts.pathspec.count = pathspecs_count; opts.notify_payload = expected_matched_pathspecs; memset(&exp, 0, sizeof(exp)); cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp)); cl_assert_equal_i(expected_diffed_files_count, exp.files); git_diff_free(diff); }
void test_apply_both__two_deltas_one_new_file(void) { git_diff *diff; struct merge_index_entry both_expected[] = { { 0100644, "f51658077d85f2264fa179b4d0848268cb3475c3", 0, "asparagus.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "08d4c445cf0078f3d9b604b82f32f4d87e083325", 0, "newfile.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "94d2c01087f48213bd157222d54edfefd77c9bba", 0, "veal.txt" } }; size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); cl_git_pass(git_diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_NEW_FILE, strlen(DIFF_TWO_DELTAS_ONE_NEW_FILE))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, both_expected, both_expected_cnt); validate_apply_workdir(repo, both_expected, both_expected_cnt); git_diff_free(diff); }
std::vector<std::string> Commit::getAffectedFiles() const { git_tree* tree = nullptr; git_tree* tree2 = nullptr; int error = git_commit_tree(&tree, get()); throw_on_error(error); try { error = git_commit_tree(&tree2, parent(0).get()); } catch (GitException e) { tree2 = nullptr; // probably initial commit } git_diff* diff = nullptr; git_diff_tree_to_tree(&diff, getRepo(), tree2, tree, 0); std::vector<std::string> ret; git_diff_foreach(diff, [](const git_diff_delta* entry, float progress, void* payload) { std::string str = entry->old_file.path; ((std::vector<std::string>*)payload)->push_back(str); return 0; }, nullptr, nullptr, &ret); git_tree_free(tree); git_tree_free(tree2); git_diff_free(diff); return ret; }
void test_diff_index__not_in_head_conflicted(void) { const char *a_commit = "26a125ee1bf"; /* the current HEAD */ git_index_entry theirs = {{0}}; git_index *index; git_diff *diff; const git_diff_delta *delta; git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_read_tree(index, a)); theirs.path = "file_not_in_head"; theirs.mode = GIT_FILEMODE_BLOB; git_oid_fromstr(&theirs.id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"); cl_git_pass(git_index_conflict_add(index, NULL, NULL, &theirs)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, NULL)); cl_assert_equal_i(git_diff_num_deltas(diff), 1); delta = git_diff_get_delta(diff, 0); cl_assert_equal_i(delta->status, GIT_DELTA_CONFLICTED); git_diff_free(diff); git_index_free(index); git_tree_free(a); }
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); }
static void assert_email_match( const char *expected, const char *oidstr, git_diff_format_email_options *opts) { git_oid oid; git_commit *commit = NULL; git_diff *diff = NULL; git_buf buf = GIT_BUF_INIT; git_oid_fromstr(&oid, oidstr); cl_git_pass(git_commit_lookup(&commit, repo, &oid)); opts->id = git_commit_id(commit); opts->author = git_commit_author(commit); if (!opts->summary) opts->summary = git_commit_summary(commit); cl_git_pass(git_diff__commit(&diff, repo, commit, NULL)); cl_git_pass(git_diff_format_email(&buf, diff, opts)); cl_assert_equal_s(expected, git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_diff_commit_as_email( &buf, repo, commit, 1, 1, opts->flags, NULL)); cl_assert_equal_s(expected, git_buf_cstr(&buf)); git_diff_free(diff); git_commit_free(commit); git_buf_free(&buf); }
void test_diff_binary__empty_for_no_diff(void) { git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_oid id; git_commit *commit; git_tree *tree; git_diff *diff; git_buf actual = GIT_BUF_INIT; opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY; opts.id_abbrev = GIT_OID_HEXSZ; repo = cl_git_sandbox_init("renames"); cl_git_pass(git_oid_fromstr(&id, "19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13")); cl_git_pass(git_commit_lookup(&commit, repo, &id)); cl_git_pass(git_commit_tree(&tree, commit)); cl_git_pass(git_diff_tree_to_tree(&diff, repo, tree, tree, &opts)); cl_git_pass(git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, git_diff_print_callback__to_buf, &actual)); cl_assert_equal_s("", actual.ptr); git_buf_dispose(&actual); git_diff_free(diff); git_commit_free(commit); git_tree_free(tree); }
void test_apply_both__rename_delta_after_modify_delta(void) { git_diff *diff; struct merge_index_entry both_expected[] = { { 0100644, "f51658077d85f2264fa179b4d0848268cb3475c3", 0, "asparagus.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "292cb60ce5e25c337c5b6e12957bbbfe1be4bf49", 0, "other.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "c8c120f466591bbe3b8867361d5ec3cdd9fda756", 0, "veal.txt" } }; size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY, strlen(DIFF_RENAME_AFTER_MODIFY))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, both_expected, both_expected_cnt); validate_apply_workdir(repo, both_expected, both_expected_cnt); git_diff_free(diff); }
void test_diff_binary__print_patch_from_diff(void) { git_index *index; git_diff *diff; git_buf actual = GIT_BUF_INIT; git_diff_options opts = GIT_DIFF_OPTIONS_INIT; const char *expected = "diff --git a/untimely.txt b/untimely.txt\n" \ "index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \ "GIT binary patch\n" \ "delta 32\n" \ "nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \ "\n" \ "delta 7\n" \ "Oc%18D`@*{63ljhg(E~C7\n" \ "\n"; opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY; opts.id_abbrev = GIT_OID_HEXSZ; repo = cl_git_sandbox_init("renames"); cl_git_pass(git_repository_index(&index, repo)); cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n"); cl_git_pass(git_diff_index_to_workdir(&diff, repo, index, &opts)); cl_git_pass(git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, print_cb, &actual)); cl_assert_equal_s(expected, actual.ptr); git_buf_dispose(&actual); git_diff_free(diff); git_index_free(index); }
void test_apply_both__rename_1_to_2(void) { git_diff *diff; struct merge_index_entry both_expected[] = { { 0100644, "f51658077d85f2264fa179b4d0848268cb3475c3", 0, "1.txt" }, { 0100644, "f51658077d85f2264fa179b4d0848268cb3475c3", 0, "2.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "94d2c01087f48213bd157222d54edfefd77c9bba", 0, "veal.txt" } }; size_t both_expected_cnt = sizeof(both_expected) / sizeof(struct merge_index_entry); cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_1_TO_2, strlen(DIFF_RENAME_1_TO_2))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, both_expected, both_expected_cnt); validate_apply_workdir(repo, both_expected, both_expected_cnt); git_diff_free(diff); }
void test_diff_index__1(void) { /* grabbed a couple of commit oids from the history of the attr repo */ const char *a_commit = "26a125ee1bf"; /* the current HEAD */ const char *b_commit = "0017bd4ab1ec3"; /* the start */ git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit); git_tree *b = resolve_commit_oid_to_tree(g_repo, b_commit); git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_diff *diff = NULL; diff_expects exp; cl_assert(a); cl_assert(b); opts.context_lines = 1; opts.interhunk_lines = 1; memset(&exp, 0, sizeof(exp)); cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts)); cl_assert_equal_i(1, git_diff_foreach( diff, diff_stop_after_2_files, NULL, NULL, NULL, &exp) ); cl_assert_equal_i(2, exp.files); git_diff_free(diff); diff = NULL; git_tree_free(a); git_tree_free(b); }
void test_apply_both__application_failure_leaves_workdir_unmodified(void) { git_diff *diff; git_index *index; const char *diff_file = DIFF_MODIFY_TWO_FILES; struct merge_index_entry workdir_expected[] = { { 0100644, "f51658077d85f2264fa179b4d0848268cb3475c3", 0, "asparagus.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "8684724651336001c5dbce74bed6736d2443958d", 0, "veal.txt" }, }; size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); /* mutate the workdir */ cl_git_rewritefile("merge-recursive/veal.txt", "This is a modification.\n"); cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_add_bypath(index, "veal.txt")); cl_git_pass(git_index_write(index)); git_index_free(index); cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt); git_diff_free(diff); }
void test_apply_both__index_must_match_workdir(void) { git_diff *diff; git_index *index; git_index_entry idx_entry; const char *diff_file = DIFF_MODIFY_TWO_FILES; /* * Append a line to the end of the file in both the index and the * working directory. Although the appended line would allow for * patch application in each, the line appended is different in * each, so the application should not be allowed. */ cl_git_append2file("merge-recursive/asparagus.txt", "This is a modification.\n"); cl_git_pass(git_repository_index(&index, repo)); memset(&idx_entry, 0, sizeof(git_index_entry)); idx_entry.mode = 0100644; idx_entry.path = "asparagus.txt"; cl_git_pass(git_oid_fromstr(&idx_entry.id, "06d3fefb8726ab1099acc76e02dfb85e034b2538")); cl_git_pass(git_index_add(index, &idx_entry)); cl_git_pass(git_index_write(index)); git_index_free(index); cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); git_diff_free(diff); }
void test_diff_format_email__invalid_no(void) { git_oid oid; git_commit *commit = NULL; git_diff *diff = NULL; git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; git_buf buf = GIT_BUF_INIT; git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92"); cl_git_pass(git_commit_lookup(&commit, repo, &oid)); opts.id = git_commit_id(commit); opts.author = git_commit_author(commit); opts.summary = git_commit_summary(commit); opts.patch_no = 2; opts.total_patches = 1; cl_git_pass(git_diff__commit(&diff, repo, commit, NULL)); cl_git_fail(git_diff_format_email(&buf, diff, &opts)); cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 2, 1, 0, NULL)); cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 0, 0, 0, NULL)); git_diff_free(diff); git_commit_free(commit); git_buf_free(&buf); }
static void Diff_dealloc(Diff *self) { git_diff_free(self->list); Py_CLEAR(self->repo); PyObject_Del(self); }
/** * Determines whether or not the working directory has non-committed changes. */ static int sync_local_dirty(int *out, git_repository *repo, git_oid *commit_id) { int e = 0; git_tree *tree = NULL; git_diff *diff = NULL; if (git_repository_is_bare(repo)) { *out = 0; goto exit; } git_oid tree_id; git_check(sync_get_tree(&tree_id, repo, commit_id)); git_check(git_tree_lookup(&tree, repo, &tree_id)); git_diff_options diff_options = GIT_DIFF_OPTIONS_INIT; diff_options.flags |= GIT_DIFF_INCLUDE_UNTRACKED; git_check(git_diff_tree_to_workdir(&diff, repo, tree, &diff_options)); *out = git_diff_num_deltas(diff); exit: if (tree) git_tree_free(tree); if (diff) git_diff_free(diff); return e; }
static int rebase_ensure_not_dirty( git_repository *repo, bool check_index, bool check_workdir, int fail_with) { git_tree *head = NULL; git_index *index = NULL; git_diff *diff = NULL; int error = 0; if (check_index) { if ((error = git_repository_head_tree(&head, repo)) < 0 || (error = git_repository_index(&index, repo)) < 0 || (error = git_diff_tree_to_index(&diff, repo, head, index, NULL)) < 0) goto done; if (git_diff_num_deltas(diff) > 0) { git_error_set(GIT_ERROR_REBASE, "uncommitted changes exist in index"); error = fail_with; goto done; } git_diff_free(diff); diff = NULL; } if (check_workdir) { git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT; diff_opts.ignore_submodules = GIT_SUBMODULE_IGNORE_UNTRACKED; if ((error = git_diff_index_to_workdir(&diff, repo, index, &diff_opts)) < 0) goto done; if (git_diff_num_deltas(diff) > 0) { git_error_set(GIT_ERROR_REBASE, "unstaged changes exist in workdir"); error = fail_with; goto done; } } done: git_diff_free(diff); git_index_free(index); git_tree_free(head); return error; }
void test_diff_tree__0(void) { /* grabbed a couple of commit oids from the history of the attr repo */ const char *a_commit = "605812a"; const char *b_commit = "370fe9ec22"; const char *c_commit = "f5b0af1fb4f5c"; git_tree *c; g_repo = cl_git_sandbox_init("attr"); cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL); cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL); cl_assert((c = resolve_commit_oid_to_tree(g_repo, c_commit)) != NULL); opts.context_lines = 1; opts.interhunk_lines = 1; cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts)); cl_git_pass(git_diff_foreach( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect)); cl_assert_equal_i(5, expect.files); cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]); cl_assert_equal_i(1, expect.file_status[GIT_DELTA_DELETED]); cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]); cl_assert_equal_i(5, expect.hunks); cl_assert_equal_i(7 + 24 + 1 + 6 + 6, expect.lines); cl_assert_equal_i(1, expect.line_ctxt); cl_assert_equal_i(24 + 1 + 5 + 5, expect.line_adds); cl_assert_equal_i(7 + 1, expect.line_dels); git_diff_free(diff); diff = NULL; memset(&expect, 0, sizeof(expect)); cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts)); cl_git_pass(git_diff_foreach( diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect)); cl_assert_equal_i(2, expect.files); cl_assert_equal_i(0, expect.file_status[GIT_DELTA_ADDED]); cl_assert_equal_i(0, expect.file_status[GIT_DELTA_DELETED]); cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]); cl_assert_equal_i(2, expect.hunks); cl_assert_equal_i(8 + 15, expect.lines); cl_assert_equal_i(1, expect.line_ctxt); cl_assert_equal_i(1, expect.line_adds); cl_assert_equal_i(7 + 14, expect.line_dels); git_tree_free(c); }
static int rebase_ensure_not_dirty( git_repository *repo, bool check_index, bool check_workdir, int fail_with) { git_tree *head = NULL; git_index *index = NULL; git_diff *diff = NULL; int error = 0; if (check_index) { if ((error = git_repository_head_tree(&head, repo)) < 0 || (error = git_repository_index(&index, repo)) < 0 || (error = git_diff_tree_to_index(&diff, repo, head, index, NULL)) < 0) goto done; if (git_diff_num_deltas(diff) > 0) { giterr_set(GITERR_REBASE, "Uncommitted changes exist in index"); error = fail_with; goto done; } git_diff_free(diff); diff = NULL; } if (check_workdir) { if ((error = git_diff_index_to_workdir(&diff, repo, index, NULL)) < 0) goto done; if (git_diff_num_deltas(diff) > 0) { giterr_set(GITERR_REBASE, "Unstaged changes exist in workdir"); error = fail_with; goto done; } } done: git_diff_free(diff); git_index_free(index); git_tree_free(head); return error; }
void git_diff_stats_free(git_diff_stats *stats) { if (stats == NULL) return; git_diff_free(stats->diff); /* bumped refcount in constructor */ git__free(stats->filestats); git__free(stats); }
void test_diff_tree__cleanup(void) { git_diff_free(diff); git_tree_free(a); git_tree_free(b); cl_git_sandbox_cleanup(); }
static void *run_index_diffs_with_modifier(void *arg) { int thread = *(int *)arg; git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_diff *diff = NULL; git_index *idx = NULL; git_repository *repo; cl_git_pass(git_repository_open(&repo, git_repository_path(_repo))); cl_git_pass(git_repository_index(&idx, repo)); /* have first thread altering the index as we go */ if (thread == 0) { int i; for (i = 0; i < 300; ++i) { switch (i & 0x03) { case 0: (void)git_index_add_bypath(idx, "new_file"); break; case 1: (void)git_index_remove_bypath(idx, "modified_file"); break; case 2: (void)git_index_remove_bypath(idx, "new_file"); break; case 3: (void)git_index_add_bypath(idx, "modified_file"); break; } git_thread_yield(); } goto done; } /* only use explicit index in this test to prevent reloading */ switch (thread & 0x03) { case 0: /* diff index to workdir */; cl_git_pass(git_diff_index_to_workdir(&diff, repo, idx, &opts)); break; case 1: /* diff tree 'a' to index */; cl_git_pass(git_diff_tree_to_index(&diff, repo, _a, idx, &opts)); break; case 2: /* diff tree 'b' to index */; cl_git_pass(git_diff_tree_to_index(&diff, repo, _b, idx, &opts)); break; case 3: /* diff index to workdir reversed */; opts.flags |= GIT_DIFF_REVERSE; cl_git_pass(git_diff_index_to_workdir(&diff, repo, idx, &opts)); break; } /* results will be unpredictable with index modifier thread running */ git_diff_free(diff); done: git_index_free(idx); git_repository_free(repo); git_error_clear(); return arg; }
void test_diff_parse__get_patch_from_diff(void) { git_repository *repo; git_diff *computed, *parsed; git_tree *a, *b; git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_buf computed_buf = GIT_BUF_INIT; git_patch *patch_computed, *patch_parsed; repo = cl_git_sandbox_init("diff"); opts.flags = GIT_DIFF_SHOW_BINARY; cl_assert((a = resolve_commit_oid_to_tree(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")) != NULL); cl_assert((b = resolve_commit_oid_to_tree(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")) != NULL); cl_git_pass(git_diff_tree_to_tree(&computed, repo, a, b, &opts)); cl_git_pass(git_diff_to_buf(&computed_buf, computed, GIT_DIFF_FORMAT_PATCH)); cl_git_pass(git_patch_from_diff(&patch_computed, computed, 0)); cl_git_pass(git_diff_from_buffer(&parsed, computed_buf.ptr, computed_buf.size)); cl_git_pass(git_patch_from_diff(&patch_parsed, parsed, 0)); cl_assert_equal_i( git_patch_num_hunks(patch_computed), git_patch_num_hunks(patch_parsed)); git_patch_free(patch_computed); git_patch_free(patch_parsed); git_tree_free(a); git_tree_free(b); git_diff_free(computed); git_diff_free(parsed); git_buf_free(&computed_buf); cl_git_sandbox_cleanup(); }
void test_apply_both__cant_modify_source_path_after_rename(void) { git_diff *diff; cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_SOURCE_PATH, strlen(DIFF_RENAME_AND_MODIFY_SOURCE_PATH))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); git_diff_free(diff); }
void test_apply_both__cant_rename_after_modify_nonexistent_target_path(void) { git_diff *diff; cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY_TARGET_PATH, strlen(DIFF_RENAME_AFTER_MODIFY_TARGET_PATH))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); git_diff_free(diff); }
void test_apply_both__cant_remove_file_twice(void) { git_diff *diff; cl_git_pass(git_diff_from_buffer(&diff, DIFF_REMOVE_FILE_TWICE, strlen(DIFF_REMOVE_FILE_TWICE))); cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); git_diff_free(diff); }
static void test_tree_to_tree_computed_to_parsed( const char *sandbox, const char *a_id, const char *b_id, uint32_t diff_flags, uint32_t find_flags) { git_repository *repo; git_diff *computed, *parsed; git_tree *a, *b; git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_diff_find_options findopts = GIT_DIFF_FIND_OPTIONS_INIT; git_buf computed_buf = GIT_BUF_INIT; repo = cl_git_sandbox_init(sandbox); opts.id_abbrev = GIT_OID_HEXSZ; opts.flags = GIT_DIFF_SHOW_BINARY | diff_flags; findopts.flags = find_flags; cl_assert((a = resolve_commit_oid_to_tree(repo, a_id)) != NULL); cl_assert((b = resolve_commit_oid_to_tree(repo, b_id)) != NULL); cl_git_pass(git_diff_tree_to_tree(&computed, repo, a, b, &opts)); if (find_flags) cl_git_pass(git_diff_find_similar(computed, &findopts)); cl_git_pass(git_diff_to_buf(&computed_buf, computed, GIT_DIFF_FORMAT_PATCH)); cl_git_pass(git_diff_from_buffer(&parsed, computed_buf.ptr, computed_buf.size)); diff_assert_equal(computed, parsed); git_tree_free(a); git_tree_free(b); git_diff_free(computed); git_diff_free(parsed); git_buf_free(&computed_buf); cl_git_sandbox_cleanup(); }