void test_checkout_crlf__autocrlf_true_index_size_is_filtered_size(void) { git_index *index; const git_index_entry *entry; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_repo_set_bool(g_repo, "core.autocrlf", true); git_checkout_head(g_repo, &opts); git_repository_index(&index, g_repo); cl_assert((entry = git_index_get_bypath(index, "all-lf", 0)) != NULL); if (GIT_EOL_NATIVE == GIT_EOL_LF) cl_assert_equal_sz(strlen(ALL_LF_TEXT_RAW), entry->file_size); else cl_assert_equal_sz(strlen(ALL_LF_TEXT_AS_CRLF), entry->file_size); cl_assert((entry = git_index_get_bypath(index, "all-crlf", 0)) != NULL); cl_assert_equal_sz(strlen(ALL_CRLF_TEXT_RAW), entry->file_size); git_index_free(index); }
void test_index_racy__read_tree_clears_uptodate_bit(void) { git_index *index; git_tree *tree; const git_index_entry *entry; git_oid id; setup_uptodate_files(); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_write_tree_to(&id, index, g_repo)); cl_git_pass(git_tree_lookup(&tree, g_repo, &id)); cl_git_pass(git_index_read_tree(index, tree)); /* ensure that no files are uptodate */ cl_assert((entry = git_index_get_bypath(index, "A", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(index, "B", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(index, "C", 0))); cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); git_tree_free(tree); git_index_free(index); }
void test_index_tests__add_issue_1397(void) { git_index *index; git_repository *repo; const git_index_entry *entry; git_oid id1; cl_set_cleanup(&cleanup_1397, NULL); repo = cl_git_sandbox_init("issue_1397"); cl_repo_set_bool(repo, "core.autocrlf", true); /* Ensure we're the only guy in the room */ cl_git_pass(git_repository_index(&index, repo)); /* Store the expected hash of the file/blob * This has been generated by executing the following * $ git hash-object crlf_file.txt */ cl_git_pass(git_oid_fromstr(&id1, "8312e0889a9cbab77c732b6bc39b51a683e3a318")); /* Make sure the initial SHA-1 is correct */ cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL); cl_assert_equal_oid(&id1, &entry->id); /* Update the index */ cl_git_pass(git_index_add_bypath(index, "crlf_file.txt")); /* Check the new SHA-1 */ cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL); cl_assert_equal_oid(&id1, &entry->id); git_index_free(index); }
void test_index_tests__remove_entry(void) { git_repository *repo; git_index *index; p_mkdir("index_test", 0770); cl_git_pass(git_repository_init(&repo, "index_test", 0)); cl_git_pass(git_repository_index(&index, repo)); cl_assert(git_index_entrycount(index) == 0); cl_git_mkfile("index_test/hello", NULL); cl_git_pass(git_index_add_bypath(index, "hello")); cl_git_pass(git_index_write(index)); cl_git_pass(git_index_read(index, true)); /* reload */ cl_assert(git_index_entrycount(index) == 1); cl_assert(git_index_get_bypath(index, "hello", 0) != NULL); cl_git_pass(git_index_remove(index, "hello", 0)); cl_git_pass(git_index_write(index)); cl_git_pass(git_index_read(index, true)); /* reload */ cl_assert(git_index_entrycount(index) == 0); cl_assert(git_index_get_bypath(index, "hello", 0) == NULL); git_index_free(index); git_repository_free(repo); cl_fixture_cleanup("index_test"); }
void test_checkout_tree__filemode_preserved_in_index(void) { git_oid executable_oid; git_commit *commit; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; git_index *index; const git_index_entry *entry; opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_git_pass(git_repository_index(&index, g_repo)); /* test a freshly added executable */ cl_git_pass(git_oid_fromstr(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6")); cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid)); cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_assert(entry = git_index_get_bypath(index, "executable.txt", 0)); cl_assert(GIT_PERMS_IS_EXEC(entry->mode)); git_commit_free(commit); /* Now start with a commit which has a text file */ cl_git_pass(git_oid_fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9")); cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid)); cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_assert(entry = git_index_get_bypath(index, "a/b.txt", 0)); cl_assert(!GIT_PERMS_IS_EXEC(entry->mode)); git_commit_free(commit); /* And then check out to a commit which converts the text file to an executable */ cl_git_pass(git_oid_fromstr(&executable_oid, "144344043ba4d4a405da03de3844aa829ae8be0e")); cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid)); cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_assert(entry = git_index_get_bypath(index, "a/b.txt", 0)); cl_assert(GIT_PERMS_IS_EXEC(entry->mode)); git_commit_free(commit); /* Finally, check out the text file again and check that the exec bit is cleared */ cl_git_pass(git_oid_fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9")); cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid)); cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_assert(entry = git_index_get_bypath(index, "a/b.txt", 0)); cl_assert(!GIT_PERMS_IS_EXEC(entry->mode)); git_commit_free(commit); git_index_free(index); }
void test_filter_custom__order_dependency(void) { git_index *index; git_blob *blob; git_buf buf = { 0 }; /* so if ident and reverse are used together, an interesting thing * happens - a reversed "$Id$" string is no longer going to trigger * ident correctly. When checking out, the filters should be applied * in order CLRF, then ident, then reverse, so ident expansion should * work correctly. On check in, the content should be reversed, then * ident, then CRLF filtered. Let's make sure that works... */ cl_git_mkfile( "empty_standard_repo/.gitattributes", "hero.*.rev-ident text ident prereverse eol=lf\n"); cl_git_mkfile( "empty_standard_repo/hero.1.rev-ident", "This is a test\n$Id$\nHave fun!\n"); cl_git_mkfile( "empty_standard_repo/hero.2.rev-ident", "Another test\n$dI$\nCrazy!\n"); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_add_bypath(index, "hero.1.rev-ident")); cl_git_pass(git_index_add_bypath(index, "hero.2.rev-ident")); cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "Filter chains\n"); git_index_free(index); cl_git_pass(git_blob_lookup(&blob, g_repo, & git_index_get_bypath(index, "hero.1.rev-ident", 0)->oid)); cl_assert_equal_s( "\n!nuf evaH\n$dI$\ntset a si sihT", git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.1.rev-ident", 0)); /* no expansion because id was reversed at checkin and now at ident * time, reverse is not applied yet */ cl_assert_equal_s( "This is a test\n$Id$\nHave fun!\n", buf.ptr); git_blob_free(blob); cl_git_pass(git_blob_lookup(&blob, g_repo, & git_index_get_bypath(index, "hero.2.rev-ident", 0)->oid)); cl_assert_equal_s( "\n!yzarC\n$Id$\ntset rehtonA", git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.2.rev-ident", 0)); /* expansion because reverse was applied at checkin and at ident time, * reverse is not applied yet */ cl_assert_equal_s( "Another test\n$59001fe193103b1016b27027c0c827d036fd0ac8 :dI$\nCrazy!\n", buf.ptr); cl_assert_equal_i(0, git_oid_strcmp( git_blob_id(blob), "8ca0df630d728c0c72072b6101b301391ef10095")); git_blob_free(blob); git_buf_free(&buf); }
/* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */ void test_merge_workdir_trivial__6(void) { const git_index_entry *entry; cl_git_pass(merge_trivial("trivial-6", "trivial-6-branch", 0)); cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 1); cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-both.txt", 1)); }
/* 4: ancest:(empty)^, head:head, remote:remote = result:no merge */ void test_merge_workdir_trivial__4(void) { const git_index_entry *entry; cl_git_pass(merge_trivial("trivial-4", "trivial-4-branch", 0)); cl_assert((entry = git_index_get_bypath(repo_index, "new-and-different.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 2); cl_assert(entry = git_index_get_bypath(repo_index, "new-and-different.txt", 2)); cl_assert(entry = git_index_get_bypath(repo_index, "new-and-different.txt", 3)); }
/* 11: ancest:ancest+, head:head, remote:remote = result:no merge */ void test_merge_workdir_trivial__11(void) { const git_index_entry *entry; cl_git_pass(merge_trivial("trivial-11", "trivial-11-branch", 0)); cl_assert((entry = git_index_get_bypath(repo_index, "modified-in-both.txt", 0)) == NULL); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 3); cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-both.txt", 1)); cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-both.txt", 2)); cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-both.txt", 3)); }
static void setup_race(void) { git_buf path = GIT_BUF_INIT; git_index *index; git_index_entry *entry; struct stat st; /* Make sure we do have a timestamp */ cl_git_pass(git_repository_index__weakptr(&index, g_repo)); cl_git_pass(git_index_write(index)); cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A")); cl_git_mkfile(path.ptr, "A"); cl_git_pass(git_index_add_bypath(index, "A")); cl_git_mkfile(path.ptr, "B"); cl_git_pass(git_index_write(index)); cl_git_mkfile(path.ptr, ""); cl_git_pass(p_stat(path.ptr, &st)); cl_assert(entry = (git_index_entry *)git_index_get_bypath(index, "A", 0)); /* force a race */ entry->mtime.seconds = (int32_t)st.st_mtime; entry->mtime.nanoseconds = (int32_t)st.st_mtime_nsec; git_buf_dispose(&path); }
PyObject * Index_getitem(Index *self, PyObject *value) { long idx; char *path; const git_index_entry *index_entry; /* Case 1: integer */ if (PyLong_Check(value)) { idx = PyLong_AsLong(value); if (idx == -1 && PyErr_Occurred()) return NULL; if (idx < 0) { PyErr_SetObject(PyExc_ValueError, value); return NULL; } index_entry = git_index_get_byindex(self->index, (size_t)idx); /* Case 2: byte or text string */ } else { path = py_path_to_c_str(value); if (!path) return NULL; index_entry = git_index_get_bypath(self->index, path, 0); free(path); } if (!index_entry) { PyErr_SetObject(PyExc_KeyError, value); return NULL; } return wrap_index_entry(index_entry, self); }
void test_index_nsec__staging_maintains_other_nanos(void) { const git_index_entry *entry; bool expect_nsec, test_file_has_nsec; expect_nsec = should_expect_nsecs(); test_file_has_nsec = try_create_file_with_nsec_timestamp("nsecs/a.txt"); cl_assert_equal_b(expect_nsec, test_file_has_nsec); cl_git_pass(git_index_add_bypath(repo_index, "a.txt")); cl_git_pass(git_index_write(repo_index)); cl_git_pass(git_index_write(repo_index)); git_index_read(repo_index, 1); cl_assert_equal_b(true, has_nsecs()); cl_assert((entry = git_index_get_bypath(repo_index, "a.txt", 0))); /* if we are writing nanoseconds to the index, expect them to be * nonzero. */ if (expect_nsec) { cl_assert(entry->ctime.nanoseconds != 0); cl_assert(entry->mtime.nanoseconds != 0); } else { cl_assert_equal_i(0, entry->ctime.nanoseconds); cl_assert_equal_i(0, entry->mtime.nanoseconds); } }
ERL_NIF_TERM geef_index_get(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { unsigned int stage; ErlNifBinary path; geef_index *index; const git_index_entry *entry; if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index)) return enif_make_badarg(env); if (!enif_get_uint(env, argv[2], &stage)) return enif_make_badarg(env); if (!enif_inspect_iolist_as_binary(env, argv[1], &path)) return enif_make_badarg(env); if (geef_terminate_binary(&path) < 0) { enif_release_binary(&path); return geef_oom(env); } entry = git_index_get_bypath(index->index, (char *) path.data, stage); enif_release_binary(&path); if (entry == NULL) return geef_error(env); return entry_to_term(env, entry); }
static void setup_uptodate_files(void) { git_buf path = GIT_BUF_INIT; git_index *index; const git_index_entry *a_entry; git_index_entry new_entry = {{0}}; cl_git_pass(git_repository_index(&index, g_repo)); 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_index_add_bypath(index, "A")); cl_assert((a_entry = git_index_get_bypath(index, "A", 0))); /* Put 'B' into the index */ new_entry.path = "B"; new_entry.mode = GIT_FILEMODE_BLOB; git_oid_cpy(&new_entry.id, &a_entry->id); cl_git_pass(git_index_add(index, &new_entry)); /* Put 'C' into the index */ new_entry.path = "C"; new_entry.mode = GIT_FILEMODE_BLOB; cl_git_pass(git_index_add_frombuffer(index, &new_entry, "hello!\n", 7)); git_index_free(index); git_buf_dispose(&path); }
static int index_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { index_reader *reader = (index_reader *)_reader; const git_index_entry *entry; git_blob *blob; int error; if ((entry = git_index_get_bypath(reader->index, filename, 0)) == NULL) return GIT_ENOTFOUND; if ((error = git_blob_lookup(&blob, reader->repo, &entry->id)) < 0) goto done; if (out_id) git_oid_cpy(out_id, &entry->id); if (out_filemode) *out_filemode = entry->mode; error = git_blob__getbuf(out, blob); done: git_blob_free(blob); return error; }
static void hack_index(char *files[]) { char *filename; struct stat statbuf; git_buf path = GIT_BUF_INIT; git_index_entry *entry; size_t i; /* Update the index to suggest that checkout placed these files on * disk, keeping the object id but updating the cache, which will * emulate a Git implementation's different filter. */ for (i = 0, filename = files[i]; filename; filename = files[++i]) { git_buf_clear(&path); cl_assert(entry = (git_index_entry *) git_index_get_bypath(repo_index, filename, 0)); cl_git_pass(git_buf_printf(&path, "%s/%s", TEST_REPO_PATH, filename)); cl_git_pass(p_stat(path.ptr, &statbuf)); entry->ctime.seconds = (git_time_t)statbuf.st_ctime; entry->ctime.nanoseconds = 0; entry->mtime.seconds = (git_time_t)statbuf.st_mtime; entry->mtime.nanoseconds = 0; entry->dev = statbuf.st_dev; entry->ino = statbuf.st_ino; entry->uid = statbuf.st_uid; entry->gid = statbuf.st_gid; entry->file_size = statbuf.st_size; } git_buf_free(&path); }
static void check_stat_data(git_index *index, const char *path, bool match) { const git_index_entry *entry; struct stat st; cl_must_pass(p_lstat(path, &st)); /* skip repo base dir name */ while (*path != '/') ++path; ++path; entry = git_index_get_bypath(index, path, 0); cl_assert(entry); if (match) { cl_assert(st.st_ctime == entry->ctime.seconds); cl_assert(st.st_mtime == entry->mtime.seconds); cl_assert(st.st_size == entry->file_size); cl_assert(st.st_uid == entry->uid); cl_assert(st.st_gid == entry->gid); cl_assert_equal_i_fmt( GIT_MODE_TYPE(st.st_mode), GIT_MODE_TYPE(entry->mode), "%07o"); if (cl_is_chmod_supported()) cl_assert_equal_b( GIT_PERMS_IS_EXEC(st.st_mode), GIT_PERMS_IS_EXEC(entry->mode)); } else { /* most things will still match */ cl_assert(st.st_size != entry->file_size); /* would check mtime, but with second resolution it won't work :( */ } }
void test_merge_workdir_simple__binary(void) { git_oid our_oid, their_oid, our_file_oid; git_commit *our_commit; git_merge_head *their_head; const git_index_entry *binary_entry; struct merge_index_entry merge_index_entries[] = { { 0100644, "1c51d885170f57a0c4e8c69ff6363d91a5b51f85", 1, "binary" }, { 0100644, "23ed141a6ae1e798b2f721afedbe947c119111ba", 2, "binary" }, { 0100644, "836b8b82b26cab22eaaed8820877c76d6c8bca19", 3, "binary" }, }; cl_git_pass(git_oid_fromstr(&our_oid, "cc338e4710c9b257106b8d16d82f86458d5beaf1")); cl_git_pass(git_oid_fromstr(&their_oid, "ad01aebfdf2ac13145efafe3f9fcf798882f1730")); cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid)); cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD, NULL, NULL)); cl_git_pass(git_merge_head_from_id(&their_head, repo, &their_oid)); cl_git_pass(git_merge(repo, (const git_merge_head **)&their_head, 1, NULL, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 3)); cl_git_pass(git_index_add_bypath(repo_index, "binary")); cl_assert((binary_entry = git_index_get_bypath(repo_index, "binary", 0)) != NULL); cl_git_pass(git_oid_fromstr(&our_file_oid, "23ed141a6ae1e798b2f721afedbe947c119111ba")); cl_assert(git_oid_cmp(&binary_entry->id, &our_file_oid) == 0); git_merge_head_free(their_head); git_commit_free(our_commit); }
void test_index_tests__remove_directory(void) { git_repository *repo; git_index *index; p_mkdir("index_test", 0770); cl_git_pass(git_repository_init(&repo, "index_test", 0)); cl_git_pass(git_repository_index(&index, repo)); cl_assert_equal_i(0, (int)git_index_entrycount(index)); p_mkdir("index_test/a", 0770); cl_git_mkfile("index_test/a/1.txt", NULL); cl_git_mkfile("index_test/a/2.txt", NULL); cl_git_mkfile("index_test/a/3.txt", NULL); cl_git_mkfile("index_test/b.txt", NULL); cl_git_pass(git_index_add_bypath(index, "a/1.txt")); cl_git_pass(git_index_add_bypath(index, "a/2.txt")); cl_git_pass(git_index_add_bypath(index, "a/3.txt")); cl_git_pass(git_index_add_bypath(index, "b.txt")); cl_git_pass(git_index_write(index)); cl_git_pass(git_index_read(index, true)); /* reload */ cl_assert_equal_i(4, (int)git_index_entrycount(index)); cl_assert(git_index_get_bypath(index, "a/1.txt", 0) != NULL); cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL); cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); cl_git_pass(git_index_remove(index, "a/1.txt", 0)); cl_git_pass(git_index_write(index)); cl_git_pass(git_index_read(index, true)); /* reload */ cl_assert_equal_i(3, (int)git_index_entrycount(index)); cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL); cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL); cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); cl_git_pass(git_index_remove_directory(index, "a", 0)); cl_git_pass(git_index_write(index)); cl_git_pass(git_index_read(index, true)); /* reload */ cl_assert_equal_i(1, (int)git_index_entrycount(index)); cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL); cl_assert(git_index_get_bypath(index, "a/2.txt", 0) == NULL); cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL); git_index_free(index); git_repository_free(repo); cl_fixture_cleanup("index_test"); }
void test_index_tests__add_frombuffer(void) { git_index *index; git_repository *repo; git_index_entry entry; const git_index_entry *returned_entry; git_oid id1; git_blob *blob; const char *content = "hey there\n"; cl_set_cleanup(&cleanup_myrepo, NULL); /* Intialize a new repository */ cl_git_pass(git_repository_init(&repo, "./myrepo", 0)); /* Ensure we're the only guy in the room */ cl_git_pass(git_repository_index(&index, repo)); cl_assert(git_index_entrycount(index) == 0); /* Store the expected hash of the file/blob * This has been generated by executing the following * $ echo "hey there" | git hash-object --stdin */ cl_git_pass(git_oid_fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6")); /* Add the new file to the index */ memset(&entry, 0x0, sizeof(git_index_entry)); entry.mode = GIT_FILEMODE_BLOB; entry.path = "test.txt"; cl_git_pass(git_index_add_frombuffer(index, &entry, content, strlen(content))); /* Wow... it worked! */ cl_assert(git_index_entrycount(index) == 1); returned_entry = git_index_get_byindex(index, 0); /* And the built-in hashing mechanism worked as expected */ cl_assert_equal_oid(&id1, &returned_entry->id); /* And mode is the one asked */ cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode); /* Test access by path instead of index */ cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); cl_assert_equal_oid(&id1, &returned_entry->id); /* Test the blob is in the repository */ cl_git_pass(git_blob_lookup(&blob, repo, &id1)); cl_assert_equal_s( content, git_blob_rawcontent(blob)); git_blob_free(blob); git_index_free(index); git_repository_free(repo); }
/* 3ALT: ancest:(empty)+, head:head, remote:*empty* = result:head */ void test_merge_workdir_trivial__3alt(void) { const git_index_entry *entry; cl_git_pass(merge_trivial("trivial-3alt", "trivial-3alt-branch", 0)); cl_assert(entry = git_index_get_bypath(repo_index, "new-in-3alt.txt", 0)); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 0); }
/* 5ALT: ancest:*, head:head, remote:head = result:head */ void test_merge_workdir_trivial__5alt_2(void) { const git_index_entry *entry; cl_git_pass(merge_trivial("trivial-5alt-2", "trivial-5alt-2-branch", 0)); cl_assert(entry = git_index_get_bypath(repo_index, "modified-to-same.txt", 0)); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 0); }
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); }
static int has_cr_in_index(const git_filter_source *src) { git_repository *repo = git_filter_source_repo(src); const char *path = git_filter_source_path(src); git_index *index; const git_index_entry *entry; git_blob *blob; const void *blobcontent; git_off_t blobsize; bool found_cr; if (!path) return false; if (git_repository_index__weakptr(&index, repo) < 0) { giterr_clear(); return false; } if (!(entry = git_index_get_bypath(index, path, 0)) && !(entry = git_index_get_bypath(index, path, 1))) return false; if (!S_ISREG(entry->mode)) /* don't crlf filter non-blobs */ return true; if (git_blob_lookup(&blob, repo, &entry->id) < 0) return false; blobcontent = git_blob_rawcontent(blob); blobsize = git_blob_rawsize(blob); if (!git__is_sizet(blobsize)) blobsize = (size_t)-1; found_cr = (blobcontent != NULL && blobsize > 0 && memchr(blobcontent, '\r', (size_t)blobsize) != NULL); git_blob_free(blob); return found_cr; }
void test_index_tests__preserves_case(void) { git_repository *repo; git_index *index; const git_index_entry *entry; int index_caps; cl_set_cleanup(&cleanup_myrepo, NULL); cl_git_pass(git_repository_init(&repo, "./myrepo", 0)); cl_git_pass(git_repository_index(&index, repo)); index_caps = git_index_caps(index); cl_git_rewritefile("myrepo/test.txt", "hey there\n"); cl_git_pass(git_index_add_bypath(index, "test.txt")); cl_git_pass(p_rename("myrepo/test.txt", "myrepo/TEST.txt")); cl_git_rewritefile("myrepo/TEST.txt", "hello again\n"); cl_git_pass(git_index_add_bypath(index, "TEST.txt")); if (index_caps & GIT_INDEXCAP_IGNORE_CASE) cl_assert_equal_i(1, (int)git_index_entrycount(index)); else cl_assert_equal_i(2, (int)git_index_entrycount(index)); /* Test access by path instead of index */ cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); /* The path should *not* have changed without an explicit remove */ cl_assert(git__strcmp(entry->path, "test.txt") == 0); cl_assert((entry = git_index_get_bypath(index, "TEST.txt", 0)) != NULL); if (index_caps & GIT_INDEXCAP_IGNORE_CASE) /* The path should *not* have changed without an explicit remove */ cl_assert(git__strcmp(entry->path, "test.txt") == 0); else cl_assert(git__strcmp(entry->path, "TEST.txt") == 0); git_index_free(index); git_repository_free(repo); }
void test_checkout_crlf__autocrlf_false_index_size_is_unfiltered_size(void) { git_index *index; const git_index_entry *entry; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_repo_set_bool(g_repo, "core.autocrlf", false); git_checkout_head(g_repo, &opts); git_repository_index(&index, g_repo); cl_assert((entry = git_index_get_bypath(index, "all-lf", 0)) != NULL); cl_assert(entry->file_size == strlen(ALL_LF_TEXT_RAW)); cl_assert((entry = git_index_get_bypath(index, "all-crlf", 0)) != NULL); cl_assert(entry->file_size == strlen(ALL_CRLF_TEXT_RAW)); git_index_free(index); }
static bool checkout_is_workdir_modified( checkout_data *data, const git_diff_file *baseitem, const git_index_entry *wditem) { git_oid oid; const git_index_entry *ie; /* handle "modified" submodule */ if (wditem->mode == GIT_FILEMODE_COMMIT) { git_submodule *sm; unsigned int sm_status = 0; const git_oid *sm_oid = NULL; if (git_submodule_lookup(&sm, data->repo, wditem->path) < 0 || git_submodule_status(&sm_status, sm) < 0) return true; if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status)) return true; sm_oid = git_submodule_wd_id(sm); if (!sm_oid) return false; return (git_oid__cmp(&baseitem->oid, sm_oid) != 0); } /* Look at the cache to decide if the workdir is modified. If not, * we can simply compare the oid in the cache to the baseitem instead * of hashing the file. */ if ((ie = git_index_get_bypath(data->index, wditem->path, 0)) != NULL) { if (wditem->mtime.seconds == ie->mtime.seconds && wditem->mtime.nanoseconds == ie->mtime.nanoseconds && wditem->file_size == ie->file_size) return (git_oid__cmp(&baseitem->oid, &ie->oid) != 0); } /* depending on where base is coming from, we may or may not know * the actual size of the data, so we can't rely on this shortcut. */ if (baseitem->size && wditem->file_size != baseitem->size) return true; if (git_diff__oid_for_file( data->repo, wditem->path, wditem->mode, wditem->file_size, &oid) < 0) return false; return (git_oid__cmp(&baseitem->oid, &oid) != 0); }
void test_merge_driver__set_forces_text(void) { const git_index_entry *idx; /* `merge` without specifying a driver indicates `text` */ set_gitattributes_to(""); cl_repo_set_string(repo, "merge.default", "custom"); merge_branch(); cl_assert((idx = git_index_get_bypath(repo_index, "automergeable.txt", 0))); cl_assert_equal_oid(&automergeable_id, &idx->id); }
void test_index_racy__adding_to_index_is_uptodate(void) { git_index *index; const git_index_entry *entry; setup_uptodate_files(); cl_git_pass(git_repository_index(&index, g_repo)); /* ensure that they're all uptodate */ cl_assert((entry = git_index_get_bypath(index, "A", 0))); cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(index, "B", 0))); cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_assert((entry = git_index_get_bypath(index, "C", 0))); cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE)); cl_git_pass(git_index_write(index)); git_index_free(index); }
/* 14: ancest:ancest+, head:ancest, remote:remote = result:remote */ void test_merge_workdir_trivial__14(void) { const git_index_entry *entry; git_oid expected_oid; cl_git_pass(merge_trivial("trivial-14", "trivial-14-branch", 0)); cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-14-branch.txt", 0)); cl_git_pass(git_oid_fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9")); cl_assert(git_oid_cmp(&entry->oid, &expected_oid) == 0); cl_assert(git_index_reuc_entrycount(repo_index) == 0); cl_assert(merge_trivial_conflict_entrycount() == 0); }