void test_checkout_tree__can_not_update_index(void) { git_oid oid; git_object *head; unsigned int status; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; git_index *index; opts.checkout_strategy |= GIT_CHECKOUT_FORCE | GIT_CHECKOUT_DONT_UPDATE_INDEX; cl_git_pass(git_reference_name_to_id(&oid, g_repo, "HEAD")); cl_git_pass(git_object_lookup(&head, g_repo, &oid, GIT_OBJ_ANY)); cl_git_pass(git_reset(g_repo, head, GIT_RESET_HARD, &g_opts)); cl_assert_equal_i(false, git_path_isdir("./testrepo/ab/")); cl_git_pass(git_revparse_single(&g_object, g_repo, "subtrees")); cl_git_pass(git_checkout_tree(g_repo, g_object, &opts)); cl_assert_equal_i(true, git_path_isfile("./testrepo/ab/de/2.txt")); cl_git_pass(git_status_file(&status, g_repo, "ab/de/2.txt")); cl_assert_equal_i(GIT_STATUS_WT_NEW, status); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_write(index)); cl_git_pass(git_status_file(&status, g_repo, "ab/de/2.txt")); cl_assert_equal_i(GIT_STATUS_WT_NEW, status); git_object_free(head); git_index_free(index); }
void test_status_worktree__conflicted_item(void) { git_repository *repo = cl_git_sandbox_init("status"); git_index *index; unsigned int status; git_index_entry ancestor_entry, our_entry, their_entry; memset(&ancestor_entry, 0x0, sizeof(git_index_entry)); memset(&our_entry, 0x0, sizeof(git_index_entry)); memset(&their_entry, 0x0, sizeof(git_index_entry)); ancestor_entry.path = "modified_file"; git_oid_fromstr(&ancestor_entry.oid, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a"); our_entry.path = "modified_file"; git_oid_fromstr(&our_entry.oid, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a"); their_entry.path = "modified_file"; git_oid_fromstr(&their_entry.oid, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a"); cl_git_pass(git_status_file(&status, repo, "modified_file")); cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status); cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_conflict_add(index, &ancestor_entry, &our_entry, &their_entry)); cl_git_pass(git_status_file(&status, repo, "modified_file")); cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status); git_index_free(index); }
void test_status_ignore__subdirectories(void) { status_entry_single st; int ignored; git_status_options opts; GIT_UNUSED(opts); g_repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_mkfile( "empty_standard_repo/ignore_me", "I'm going to be ignored!"); cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert_equal_i(2, st.count); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_file(&st.status, g_repo, "ignore_me")); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_should_ignore(&ignored, g_repo, "ignore_me")); cl_assert(ignored); /* So, interestingly, as per the comment in diff_from_iterators() the * following file is ignored, but in a way so that it does not show up * in status even if INCLUDE_IGNORED is used. This actually matches * core git's behavior - if you follow these steps and try running "git * status -uall --ignored" then the following file and directory will * not show up in the output at all. */ cl_git_pass( git_futils_mkdir_r("empty_standard_repo/test/ignore_me", NULL, 0775)); cl_git_mkfile( "empty_standard_repo/test/ignore_me/file", "I'm going to be ignored!"); opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR; opts.flags = GIT_STATUS_OPT_INCLUDE_IGNORED | GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert_equal_i(2, st.count); cl_git_pass(git_status_file(&st.status, g_repo, "test/ignore_me/file")); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass( git_status_should_ignore(&ignored, g_repo, "test/ignore_me/file")); cl_assert(ignored); }
void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void) { unsigned int status; cl_git_pass(git_status_file(&status, repo, "macro_bad")); cl_assert(status == GIT_STATUS_CURRENT); retrieve_target_from_oid(&target, repo, "605812ab7fe421fdd325a935d35cb06a9234a7d7"); cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED)); cl_git_pass(git_status_file(&status, repo, "macro_bad")); cl_assert(status == GIT_STATUS_WT_NEW); }
void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void) { unsigned int status; cl_git_pass(git_status_file(&status, repo, "macro_bad")); cl_assert(status == GIT_STATUS_CURRENT); cl_git_pass(git_revparse_single(&target, repo, "605812a")); cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL)); cl_git_pass(git_status_file(&status, repo, "macro_bad")); cl_assert(status == GIT_STATUS_WT_NEW); }
void test_status_ignore__subdirectories(void) { status_entry_single st; int ignored; g_repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_mkfile( "empty_standard_repo/ignore_me", "I'm going to be ignored!"); cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert_equal_i(2, st.count); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_file(&st.status, g_repo, "ignore_me")); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_should_ignore(&ignored, g_repo, "ignore_me")); cl_assert(ignored); /* I've changed libgit2 so that the behavior here now differs from * core git but seems to make more sense. In core git, the following * items are skipped completed, even if --ignored is passed to status. * It you mirror these steps and run "git status -uall --ignored" then * you will not see "test/ignore_me/" in the results. * * However, we had a couple reports of this as a bug, plus there is a * similar circumstance where we were differing for core git when you * used a rooted path for an ignore, so I changed this behavior. */ cl_git_pass(git_futils_mkdir_r( "empty_standard_repo/test/ignore_me", NULL, 0775)); cl_git_mkfile( "empty_standard_repo/test/ignore_me/file", "I'm going to be ignored!"); cl_git_mkfile( "empty_standard_repo/test/ignore_me/file2", "Me, too!"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert_equal_i(3, st.count); cl_git_pass(git_status_file(&st.status, g_repo, "test/ignore_me/file")); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass( git_status_should_ignore(&ignored, g_repo, "test/ignore_me/file")); cl_assert(ignored); }
void test_status_ignore__filenames_with_special_prefixes_do_not_interfere_with_status_retrieval(void) { status_entry_single st; char *test_cases[] = { "!file", "#blah", "[blah]", "[attr]", "[attr]blah", NULL }; int i; for (i = 0; *(test_cases + i) != NULL; i++) { git_buf file = GIT_BUF_INIT; char *file_name = *(test_cases + i); git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_pass(git_buf_joinpath(&file, "empty_standard_repo", file_name)); cl_git_mkfile(git_buf_cstr(&file), "Please don't ignore me!"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(repo, cb_status__single, &st)); cl_assert(st.count == 1); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_pass(git_status_file(&st.status, repo, file_name)); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_sandbox_cleanup(); git_buf_free(&file); } }
void test_status_worktree__status_file_with_clean_index_and_empty_workdir(void) { git_repository *repo; unsigned int status = 0; git_index *index; cl_git_pass(p_mkdir("wd", 0777)); cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_git_pass(git_repository_set_workdir(repo, "wd", false)); cl_git_pass(git_index_open(&index, "my-index")); fill_index_wth_head_entries(repo, index); git_repository_set_index(repo, index); cl_git_pass(git_status_file(&status, repo, "branch_file.txt")); cl_assert_equal_i(GIT_STATUS_WT_DELETED, status); git_repository_free(repo); git_index_free(index); cl_git_pass(p_rmdir("wd")); cl_git_pass(p_unlink("my-index")); }
void test_status_worktree__new_staged_file_must_handle_crlf(void) { git_repository *repo; git_index *index; git_config *config; unsigned int status; cl_git_pass(git_repository_init(&repo, "getting_started", 0)); // Ensure that repo has core.autocrlf=true cl_git_pass(git_repository_config(&config, repo)); cl_git_pass(git_config_set_bool(config, "core.autocrlf", true)); cl_git_mkfile("getting_started/testfile.txt", "content\r\n"); // Content with CRLF cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_add_from_workdir(index, "testfile.txt")); cl_git_pass(git_index_write(index)); cl_git_pass(git_status_file(&status, repo, "testfile.txt")); cl_assert_equal_i(GIT_STATUS_INDEX_NEW, status); git_config_free(config); git_index_free(index); git_repository_free(repo); }
CharPair PmrWorkspace::gitFileStatus(const QString &pPath) const { // Retrieve and return the status of the file, which path is given CharPair res = CharPair(' ', ' '); if (isOpen()) { uint statusFlags = GIT_STATUS_CURRENT; if (git_status_file(&statusFlags, mGitRepository, QDir(mPath).relativeFilePath(pPath).toUtf8().constData()) == GIT_OK) { // Retrieve the status itself res = gitStatusChars(statusFlags); // Also update the status in our file tree if (mRepositoryStatusMap.contains(pPath)) { mRepositoryStatusMap.value(pPath)->setStatus(res); } } else { emitGitError(tr("An error occurred while trying to get the status of %1.").arg(pPath)); } } return res; }
void test_stash_save__does_not_keep_index_by_default(void) { /* $ git stash $ git show refs/stash:what see you later $ git show refs/stash:how not so small and $ git show refs/stash:who funky world $ git show refs/stash:when fatal: Path 'when' exists on disk, but not in 'stash'. $ git show refs/stash^2:what goodbye $ git show refs/stash^2:how not so small and $ git show refs/stash^2:who world $ git show refs/stash^2:when fatal: Path 'when' exists on disk, but not in 'stash^2'. $ git status --short ?? when */ unsigned int status; cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT)); cl_git_pass(git_status_file(&status, repo, "when")); assert_blob_oid("refs/stash:what", "bc99dc98b3eba0e9157e94769cd4d49cb49de449"); /* see you later */ assert_blob_oid("refs/stash:how", "e6d64adb2c7f3eb8feb493b556cc8070dca379a3"); /* not so small and */ assert_blob_oid("refs/stash:who", "a0400d4954659306a976567af43125a0b1aa8595"); /* funky world */ assert_blob_oid("refs/stash:when", NULL); assert_blob_oid("refs/stash:why", "88c2533e21f098b89c91a431d8075cbdbe422a51"); /* would anybody use stash? */ assert_blob_oid("refs/stash:where", "e3d6434ec12eb76af8dfa843a64ba6ab91014a0b"); /* .... */ assert_blob_oid("refs/stash:.gitignore", "ac4d88de61733173d9959e4b77c69b9f17a00980"); assert_blob_oid("refs/stash:just.ignore", NULL); assert_blob_oid("refs/stash^2:what", "dd7e1c6f0fefe118f0b63d9f10908c460aa317a6"); /* goodbye */ assert_blob_oid("refs/stash^2:how", "e6d64adb2c7f3eb8feb493b556cc8070dca379a3"); /* not so small and */ assert_blob_oid("refs/stash^2:who", "cc628ccd10742baea8241c5924df992b5c019f71"); /* world */ assert_blob_oid("refs/stash^2:when", NULL); assert_blob_oid("refs/stash^2:why", "88c2533e21f098b89c91a431d8075cbdbe422a51"); /* would anybody use stash? */ assert_blob_oid("refs/stash^2:where", "e08f7fbb9a42a0c5367cf8b349f1f08c3d56bd72"); /* ???? */ assert_blob_oid("refs/stash^2:.gitignore", "ac4d88de61733173d9959e4b77c69b9f17a00980"); assert_blob_oid("refs/stash^2:just.ignore", NULL); assert_blob_oid("refs/stash^3", NULL); cl_assert_equal_i(GIT_STATUS_WT_NEW, status); }
int print_matched_cb(const char *path, const char *matched_pathspec, void *payload) { struct print_payload p = *(struct print_payload*)(payload); int ret; git_status_t status; (void)matched_pathspec; if (git_status_file((unsigned int*)(&status), p.repo, path)) { return -1; //abort } if (status & GIT_STATUS_WT_MODIFIED || status & GIT_STATUS_WT_NEW) { printf("add '%s'\n", path); ret = 0; } else { ret = 1; } if(p.options & SKIP) { ret = 1; } return ret; }
void test_status_ignore__empty_repo_with_gitignore_rewrite(void) { status_entry_single st; int ignored; g_repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_mkfile( "empty_standard_repo/look-ma.txt", "I'm going to be ignored!"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert(st.count == 1); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt")); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt")); cl_assert(!ignored); cl_git_rewritefile("empty_standard_repo/.gitignore", "*.nomatch\n"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert(st.count == 2); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt")); cl_assert(st.status == GIT_STATUS_WT_NEW); cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt")); cl_assert(!ignored); cl_git_rewritefile("empty_standard_repo/.gitignore", "*.txt\n"); memset(&st, 0, sizeof(st)); cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st)); cl_assert(st.count == 2); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt")); cl_assert(st.status == GIT_STATUS_IGNORED); cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt")); cl_assert(ignored); }
/* this test is equivalent to t18-status.c:singlestatus2 */ void test_status_worktree__single_nonexistent_file_empty_repo(void) { int error; unsigned int status_flags; git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); error = git_status_file(&status_flags, repo, "nonexistent"); cl_git_fail(error); cl_assert(error == GIT_ENOTFOUND); }
/* this test is equivalent to t18-status.c:singlestatus4 */ void test_status_worktree__single_folder(void) { int error; unsigned int status_flags; git_repository *repo = cl_git_sandbox_init("status"); error = git_status_file(&status_flags, repo, "subdir"); cl_git_fail(error); cl_assert(error != GIT_ENOTFOUND); }
/* this test is equivalent to t18-status.c:singlestatus3 */ void test_status_worktree__single_file_empty_repo(void) { unsigned int status_flags; git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_mkfile("empty_standard_repo/new_file", "new_file\n"); cl_git_pass(git_status_file(&status_flags, repo, "new_file")); cl_assert(status_flags == GIT_STATUS_WT_NEW); }
int Gitarre::UpdateRepoViewEntries (int i, QTreeWidgetItem *item, QString path) { if (item->childCount() > 0) for (int j = 0; j < item->childCount(); ++j) { QString newPath = path; if (newPath.size() > 0) newPath += '/'; newPath += item->child(j)->text(0); if (UpdateRepoViewEntries (i, item->child(j), newPath)) item->removeChild(item->child(j)); } else { QColor itemColor = item->foreground(0).color(); if (itemColor == ColorIgnored) // check if file still exists { QFileInfo fileInfo (Repos[i]->GetPath() + '/' + path); if (!fileInfo.exists()) return 1; } else if (itemColor == ColorDeleted) // check if file still in index { unsigned int status; int found = git_status_file (&status, Repos[i]->GetGitRepo(), path.toStdString().c_str()); if (found == GIT_ENOTFOUND) return 1; if (!(status & GIT_STATUS_WT_DELETED)) // check if it is still absent item->setForeground (0, QBrush(ColorDefault)); } else if (itemColor == ColorNew) // check if file still exists and still new { unsigned int status; int found = git_status_file (&status, Repos[i]->GetGitRepo(), path.toStdString().c_str()); if (found == GIT_ENOTFOUND) return 1; if (!(status & GIT_STATUS_WT_NEW)) item->setForeground (0, QBrush(ColorDefault)); } } return 0; }
void test_status_ignore__ignore_pattern_contains_space(void) { unsigned int flags; const mode_t mode = 0777; g_repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_rewritefile("empty_standard_repo/.gitignore", "foo bar.txt\n"); cl_git_mkfile( "empty_standard_repo/foo bar.txt", "I'm going to be ignored!"); cl_git_pass(git_status_file(&flags, g_repo, "foo bar.txt")); cl_assert(flags == GIT_STATUS_IGNORED); cl_git_pass(git_futils_mkdir_r("empty_standard_repo/foo", NULL, mode)); cl_git_mkfile("empty_standard_repo/foo/look-ma.txt", "I'm not going to be ignored!"); cl_git_pass(git_status_file(&flags, g_repo, "foo/look-ma.txt")); cl_assert(flags == GIT_STATUS_WT_NEW); }
void test_stash_save__does_not_keep_index_by_default(void) { /* $ git stash $ git show refs/stash:what see you later $ git show refs/stash:how not so small and $ git show refs/stash:who funky world $ git show refs/stash:when fatal: Path 'when' exists on disk, but not in 'stash'. $ git show refs/stash^2:what goodbye $ git show refs/stash^2:how not so small and $ git show refs/stash^2:who world $ git show refs/stash^2:when fatal: Path 'when' exists on disk, but not in 'stash^2'. $ git status --short ?? when */ unsigned int status; cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT)); cl_git_pass(git_status_file(&status, repo, "when")); assert_blob_oid("refs/stash:what", "bc99dc98b3eba0e9157e94769cd4d49cb49de449"); /* see you later */ assert_blob_oid("refs/stash:how", "e6d64adb2c7f3eb8feb493b556cc8070dca379a3"); /* not so small and */ assert_blob_oid("refs/stash:who", "a0400d4954659306a976567af43125a0b1aa8595"); /* funky world */ assert_blob_oid("refs/stash:when", NULL); assert_blob_oid("refs/stash:just.ignore", NULL); assert_blob_oid("refs/stash^2:what", "dd7e1c6f0fefe118f0b63d9f10908c460aa317a6"); /* goodbye */ assert_blob_oid("refs/stash^2:how", "e6d64adb2c7f3eb8feb493b556cc8070dca379a3"); /* not so small and */ assert_blob_oid("refs/stash^2:who", "cc628ccd10742baea8241c5924df992b5c019f71"); /* world */ assert_blob_oid("refs/stash^2:when", NULL); assert_blob_oid("refs/stash^2:just.ignore", NULL); assert_blob_oid("refs/stash^3", NULL); cl_assert_equal_i(GIT_STATUS_WT_NEW, status); }
void test_status_worktree__cannot_retrieve_the_status_of_a_bare_repository(void) { git_repository *repo; unsigned int status = 0; cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); cl_assert_equal_i(GIT_EBAREREPO, git_status_file(&status, repo, "dummy")); git_repository_free(repo); }
void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf_issue_1397(void) { git_repository *repo = cl_git_sandbox_init("issue_1397"); unsigned int status; cl_repo_set_bool(repo, "core.autocrlf", true); cl_git_pass(git_status_file(&status, repo, "crlf_file.txt")); cl_assert_equal_i(GIT_STATUS_CURRENT, status); }
static void assert_ignore_case( bool should_ignore_case, int expected_lower_cased_file_status, int expected_camel_cased_file_status) { unsigned int status; git_buf lower_case_path = GIT_BUF_INIT, camel_case_path = GIT_BUF_INIT; git_repository *repo, *repo2; repo = cl_git_sandbox_init("empty_standard_repo"); cl_git_remove_placeholders(git_repository_path(repo), "dummy-marker.txt"); cl_repo_set_bool(repo, "core.ignorecase", should_ignore_case); cl_git_pass(git_buf_joinpath(&lower_case_path, git_repository_workdir(repo), "plop")); cl_git_mkfile(git_buf_cstr(&lower_case_path), ""); stage_and_commit(repo, "plop"); cl_git_pass(git_repository_open(&repo2, "./empty_standard_repo")); cl_git_pass(git_status_file(&status, repo2, "plop")); cl_assert_equal_i(GIT_STATUS_CURRENT, status); cl_git_pass(git_buf_joinpath(&camel_case_path, git_repository_workdir(repo), "Plop")); cl_git_pass(p_rename(git_buf_cstr(&lower_case_path), git_buf_cstr(&camel_case_path))); cl_git_pass(git_status_file(&status, repo2, "plop")); cl_assert_equal_i(expected_lower_cased_file_status, status); cl_git_pass(git_status_file(&status, repo2, "Plop")); cl_assert_equal_i(expected_camel_cased_file_status, status); git_repository_free(repo2); git_buf_free(&lower_case_path); git_buf_free(&camel_case_path); }
/* this test is equivalent to t18-status.c:singlestatus0 */ void test_status_worktree__single_file(void) { int i; unsigned int status_flags; git_repository *repo = cl_git_sandbox_init("status"); for (i = 0; i < (int)entry_count0; i++) { cl_git_pass( git_status_file(&status_flags, repo, entry_paths0[i]) ); cl_assert(entry_statuses0[i] == status_flags); } }
void test_status_worktree__file_status_honors_case_ignorecase_regarding_untracked_files(void) { git_repository *repo = cl_git_sandbox_init("status"); unsigned int status; git_index *index; cl_repo_set_bool(repo, "core.ignorecase", false); repo = cl_git_sandbox_reopen(); /* Actually returns GIT_STATUS_IGNORED on Windows */ cl_git_fail_with(git_status_file(&status, repo, "NEW_FILE"), GIT_ENOTFOUND); cl_git_pass(git_repository_index(&index, repo)); cl_git_pass(git_index_add_bypath(index, "new_file")); cl_git_pass(git_index_write(index)); git_index_free(index); /* Actually returns GIT_STATUS_IGNORED on Windows */ cl_git_fail_with(git_status_file(&status, repo, "NEW_FILE"), GIT_ENOTFOUND); }
void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf(void) { git_repository *repo = cl_git_sandbox_init("status"); unsigned int status; cl_repo_set_bool(repo, "core.autocrlf", true); cl_git_rewritefile("status/current_file", "current_file\r\n"); cl_git_pass(git_status_file(&status, repo, "current_file")); cl_assert_equal_i(GIT_STATUS_CURRENT, status); }
void test_status_worktree__cannot_retrieve_the_status_of_a_bare_repository(void) { git_repository *repo; int error; unsigned int status = 0; cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); error = git_status_file(&status, repo, "dummy"); cl_git_fail(error); cl_assert(error != GIT_ENOTFOUND); git_repository_free(repo); }
git_status_t Repository::file_status(const char * filepath) const { git_status_t res; switch (git_status_file(reinterpret_cast<unsigned int *>(&res), repo_, filepath)) { case GIT_ENOTFOUND: throw file_not_found_error(filepath); case GIT_EAMBIGUOUS: throw ambiguous_path_error(filepath); case -1: throw unknown_file_status_error(filepath); } return res; }
emacs_value egit_status_file(emacs_env *env, emacs_value _repo, emacs_value _path) { EGIT_ASSERT_REPOSITORY(_repo); EM_ASSERT_STRING(_path); git_repository *repo = EGIT_EXTRACT(_repo); char *path = EM_EXTRACT_STRING(_path); unsigned int flags; int rv = git_status_file(&flags, repo, path); free(path); EGIT_CHECK_ERROR(rv); return egit_status_decode(env, EM_INTEGER(flags)); }
void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf(void) { git_repository *repo = cl_git_sandbox_init("status"); unsigned int status; cl_repo_set_bool(repo, "core.autocrlf", true); cl_git_rewritefile("status/current_file", "current_file\r\n"); cl_git_pass(git_status_file(&status, repo, "current_file")); /* stat data on file should no longer match stat cache, even though * file diff will be empty because of line-ending conversion - matches * the Git command-line behavior here. */ cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status); }
static void assert_status( const char *path, int status_flags) { unsigned int status; int error; error = git_status_file(&status, repo, path); if (status_flags < 0) { cl_assert_equal_i(status_flags, error); return; } cl_assert_equal_i(0, error); cl_assert_equal_i((unsigned int)status_flags, status); }