| #include "clar_libgit2.h" |
| #include "../checkout/checkout_helpers.h" |
| |
| #include "buffer.h" |
| #include "index.h" |
| #include "repository.h" |
| |
| static git_repository *g_repo; |
| |
| void test_index_racy__initialize(void) |
| { |
| cl_git_pass(git_repository_init(&g_repo, "diff_racy", false)); |
| } |
| |
| void test_index_racy__cleanup(void) |
| { |
| git_repository_free(g_repo); |
| g_repo = NULL; |
| |
| cl_fixture_cleanup("diff_racy"); |
| } |
| |
| 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_free(&path); |
| } |
| |
| void test_index_racy__write_index_just_after_file(void) |
| { |
| git_index *index; |
| git_diff *diff; |
| git_buf path = GIT_BUF_INIT; |
| struct p_timeval times[2]; |
| |
| /* Make sure we do have a timestamp */ |
| cl_git_pass(git_repository_index(&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"); |
| /* Force the file's timestamp to be a second after we wrote the index */ |
| times[0].tv_sec = index->stamp.mtime.tv_sec + 1; |
| times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000; |
| times[1].tv_sec = index->stamp.mtime.tv_sec + 1; |
| times[1].tv_usec = index->stamp.mtime.tv_nsec / 1000; |
| cl_git_pass(p_utimes(path.ptr, times)); |
| |
| /* |
| * Put 'A' into the index, the size field will be filled, |
| * because the index' on-disk timestamp does not match the |
| * file's timestamp. |
| */ |
| cl_git_pass(git_index_add_bypath(index, "A")); |
| cl_git_pass(git_index_write(index)); |
| |
| cl_git_mkfile(path.ptr, "B"); |
| /* |
| * Pretend this index' modification happened a second after the |
| * file update, and rewrite the file in that same second. |
| */ |
| times[0].tv_sec = index->stamp.mtime.tv_sec + 2; |
| times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000; |
| times[1].tv_sec = index->stamp.mtime.tv_sec + 2; |
| times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000; |
| |
| cl_git_pass(p_utimes(git_index_path(index), times)); |
| cl_git_pass(p_utimes(path.ptr, times)); |
| |
| cl_git_pass(git_index_read(index, true)); |
| |
| cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL)); |
| cl_assert_equal_i(1, git_diff_num_deltas(diff)); |
| |
| git_buf_free(&path); |
| git_diff_free(diff); |
| git_index_free(index); |
| } |
| |
| |
| 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 = st.st_mtime; |
| entry->mtime.nanoseconds = st.st_mtime_nsec; |
| |
| git_buf_free(&path); |
| } |
| |
| void test_index_racy__smudges_index_entry_on_save(void) |
| { |
| git_index *index; |
| const git_index_entry *entry; |
| |
| setup_race(); |
| |
| /* write the index, which will smudge anything that had the same timestamp |
| * as the index when the index was loaded. that way future loads of the |
| * index (with the new timestamp) will know that these files were not |
| * clean. |
| */ |
| |
| cl_git_pass(git_repository_index__weakptr(&index, g_repo)); |
| cl_git_pass(git_index_write(index)); |
| |
| cl_assert(entry = git_index_get_bypath(index, "A", 0)); |
| cl_assert_equal_i(0, entry->file_size); |
| } |
| |
| void test_index_racy__detects_diff_of_change_in_identical_timestamp(void) |
| { |
| git_index *index; |
| git_diff *diff; |
| |
| cl_git_pass(git_repository_index__weakptr(&index, g_repo)); |
| |
| setup_race(); |
| |
| cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL)); |
| cl_assert_equal_i(1, git_diff_num_deltas(diff)); |
| |
| git_diff_free(diff); |
| } |
| |
| 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_free(&path); |
| } |
| |
| 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_IDXENTRY_UPTODATE, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "B", 0))); |
| cl_assert_equal_i(GIT_IDXENTRY_UPTODATE, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "C", 0))); |
| cl_assert_equal_i(GIT_IDXENTRY_UPTODATE, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_git_pass(git_index_write(index)); |
| |
| git_index_free(index); |
| } |
| |
| void test_index_racy__reading_clears_uptodate_bit(void) |
| { |
| git_index *index; |
| const git_index_entry *entry; |
| |
| setup_uptodate_files(); |
| |
| cl_git_pass(git_repository_index(&index, g_repo)); |
| cl_git_pass(git_index_write(index)); |
| |
| cl_git_pass(git_index_read(index, true)); |
| |
| /* 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_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "B", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "C", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| 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_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "B", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(index, "C", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| git_tree_free(tree); |
| git_index_free(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_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_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(newindex, "B", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| cl_assert((entry = git_index_get_bypath(newindex, "C", 0))); |
| cl_assert_equal_i(0, (entry->flags_extended & GIT_IDXENTRY_UPTODATE)); |
| |
| git_index_free(index); |
| git_index_free(newindex); |
| } |