#include "clar_libgit2.h"
#include "../checkout/checkout_helpers.h"
-#include "buffer.h"
#include "index.h"
#include "repository.h"
{
git_index *index;
git_diff *diff;
- git_buf path = GIT_BUF_INIT;
+ git_str path = GIT_STR_INIT;
- cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A"));
+ cl_git_pass(git_str_joinpath(&path, git_repository_workdir(g_repo), "A"));
cl_git_mkfile(path.ptr, "A");
/* Put 'A' into the index */
git_index_free(index);
git_diff_free(diff);
- git_buf_free(&path);
+ git_str_dispose(&path);
}
void test_index_racy__write_index_just_after_file(void)
{
git_index *index;
git_diff *diff;
- git_buf path = GIT_BUF_INIT;
- struct timeval times[2];
+ git_str path = GIT_STR_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_pass(git_str_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 + 1;
- times[0].tv_usec = 0;
- times[1].tv_sec = index->stamp.mtime + 1;
- times[1].tv_usec = 0;
+ 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));
/*
cl_git_mkfile(path.ptr, "B");
/*
- * Pretend this index' modification happend a second after the
+ * 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 + 2;
- times[0].tv_usec = 0;
- times[1].tv_sec = index->stamp.mtime + 2;
- times[0].tv_usec = 0;
+ 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_diff_index_to_workdir(&diff, g_repo, index, NULL));
cl_assert_equal_i(1, git_diff_num_deltas(diff));
- git_buf_free(&path);
+ git_str_dispose(&path);
git_diff_free(diff);
git_index_free(index);
}
-void test_index_racy__empty_file_after_smudge(void)
+
+static void setup_race(void)
{
+ git_str path = GIT_STR_INIT;
git_index *index;
- git_diff *diff;
- git_buf path = GIT_BUF_INIT;
- int i, found_race = 0;
- const git_index_entry *entry;
+ 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_pass(git_str_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, "");
- /* Make sure writing the file, adding and rewriting happen in the same second */
- for (i = 0; i < 10; i++) {
- struct stat st;
- cl_git_mkfile(path.ptr, "A");
+ cl_git_pass(p_stat(path.ptr, &st));
+ cl_assert(entry = (git_index_entry *)git_index_get_bypath(index, "A", 0));
- cl_git_pass(git_index_add_bypath(index, "A"));
- cl_git_mkfile(path.ptr, "B");
- cl_git_pass(git_index_write(index));
+ /* force a race */
+ entry->mtime.seconds = (int32_t)st.st_mtime;
+ entry->mtime.nanoseconds = (int32_t)st.st_mtime_nsec;
- cl_git_mkfile(path.ptr, "");
+ git_str_dispose(&path);
+}
+
+void test_index_racy__smudges_index_entry_on_save(void)
+{
+ git_index *index;
+ const git_index_entry *entry;
- cl_git_pass(p_stat(path.ptr, &st));
- cl_assert(entry = git_index_get_bypath(index, "A", 0));
- if (entry->mtime.seconds == (int32_t) st.st_mtime) {
- found_race = 1;
- break;
- }
+ 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.
+ */
- if (!found_race)
- cl_fail("failed to find race after 10 attempts");
+ 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_buf_free(&path);
git_diff_free(diff);
}
+
+static void setup_uptodate_files(void)
+{
+ git_str path = GIT_STR_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_str_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_from_buffer(index, &new_entry, "hello!\n", 7));
+
+ git_index_free(index);
+ git_str_dispose(&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_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);
+}
+
+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_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_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_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_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);
+}
projects / libgit2.git / blobdiff