[libgit2.git] / tests / index / tests.c

#include "clar_libgit2.h"
#include "index.h"

static const size_t index_entry_count = 109;
static const size_t index_entry_count_2 = 1437;
#define TEST_INDEX_PATH cl_fixture("testrepo.git/index")
#define TEST_INDEX2_PATH cl_fixture("gitgit.index")
#define TEST_INDEXBIG_PATH cl_fixture("big.index")
#define TEST_INDEXBAD_PATH cl_fixture("bad.index")


/* Suite data */
struct test_entry {
   size_t index;
   char path[128];
   git_off_t file_size;
   git_time_t mtime;
};

static struct test_entry test_entries[] = {
   {4, "Makefile", 5064, 0x4C3F7F33},
   {62, "tests/Makefile", 2631, 0x4C3F7F33},
   {36, "src/index.c", 10014, 0x4C43368D},
   {6, "git.git-authors", 2709, 0x4C3F7F33},
   {48, "src/revobject.h", 1448, 0x4C3F7FE2}
};

/* Helpers */
static void copy_file(const char *src, const char *dst)
{
	git_buf source_buf = GIT_BUF_INIT;
	git_file dst_fd;

	cl_git_pass(git_futils_readbuffer(&source_buf, src));

	dst_fd = git_futils_creat_withpath(dst, 0777, 0666); /* -V536 */
	if (dst_fd < 0)
		goto cleanup;

	cl_git_pass(p_write(dst_fd, source_buf.ptr, source_buf.size));

cleanup:
	git_buf_free(&source_buf);
	p_close(dst_fd);
}

static void files_are_equal(const char *a, const char *b)
{
	git_buf buf_a = GIT_BUF_INIT;
	git_buf buf_b = GIT_BUF_INIT;
	int pass;

	if (git_futils_readbuffer(&buf_a, a) < 0)
		cl_assert(0);

	if (git_futils_readbuffer(&buf_b, b) < 0) {
		git_buf_free(&buf_a);
		cl_assert(0);
	}

	pass = (buf_a.size == buf_b.size && !memcmp(buf_a.ptr, buf_b.ptr, buf_a.size));

	git_buf_free(&buf_a);
	git_buf_free(&buf_b);

	cl_assert(pass);
}


/* Fixture setup and teardown */
void test_index_tests__initialize(void)
{
}

void test_index_tests__empty_index(void)
{
   git_index *index;

   cl_git_pass(git_index_open(&index, "in-memory-index"));
   cl_assert(index->on_disk == 0);

   cl_assert(git_index_entrycount(index) == 0);
   cl_assert(git_vector_is_sorted(&index->entries));

   git_index_free(index);
}

void test_index_tests__default_test_index(void)
{
   git_index *index;
   unsigned int i;
   git_index_entry **entries;

   cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
   cl_assert(index->on_disk);

   cl_assert(git_index_entrycount(index) == index_entry_count);
   cl_assert(git_vector_is_sorted(&index->entries));

   entries = (git_index_entry **)index->entries.contents;

   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
		git_index_entry *e = entries[test_entries[i].index];

		cl_assert_equal_s(e->path, test_entries[i].path);
		cl_assert(e->mtime.seconds == test_entries[i].mtime);
		cl_assert(e->file_size == test_entries[i].file_size);
   }

   git_index_free(index);
}

void test_index_tests__gitgit_index(void)
{
   git_index *index;

   cl_git_pass(git_index_open(&index, TEST_INDEX2_PATH));
   cl_assert(index->on_disk);

   cl_assert(git_index_entrycount(index) == index_entry_count_2);
   cl_assert(git_vector_is_sorted(&index->entries));
   cl_assert(index->tree != NULL);

   git_index_free(index);
}

void test_index_tests__find_in_existing(void)
{
   git_index *index;
   unsigned int i;

   cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));

   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
		size_t idx;

		cl_assert(!git_index_find(&idx, index, test_entries[i].path));
		cl_assert(idx == test_entries[i].index);
   }

   git_index_free(index);
}

void test_index_tests__find_in_empty(void)
{
   git_index *index;
   unsigned int i;

   cl_git_pass(git_index_open(&index, "fake-index"));

   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
		cl_assert(GIT_ENOTFOUND == git_index_find(NULL, index, test_entries[i].path));
   }

   git_index_free(index);
}

void test_index_tests__write(void)
{
   git_index *index;

   copy_file(TEST_INDEXBIG_PATH, "index_rewrite");

   cl_git_pass(git_index_open(&index, "index_rewrite"));
   cl_assert(index->on_disk);

   cl_git_pass(git_index_write(index));
   files_are_equal(TEST_INDEXBIG_PATH, "index_rewrite");

   git_index_free(index);

   p_unlink("index_rewrite");
}

void test_index_tests__sort0(void)
{
	/* sort the entires in an index */

   /*
   * TODO: This no longer applies:
   * index sorting in Git uses some specific changes to the way
   * directories are sorted.
   *
   * We need to specificially check for this by creating a new
   * index, adding entries in random order and then
   * checking for consistency
   */
}

void test_index_tests__sort1(void)
{
   /* sort the entires in an empty index */
   git_index *index;

   cl_git_pass(git_index_open(&index, "fake-index"));

   /* FIXME: this test is slightly dumb */
   cl_assert(git_vector_is_sorted(&index->entries));

   git_index_free(index);
}

static void cleanup_myrepo(void *opaque)
{
	GIT_UNUSED(opaque);
	cl_fixture_cleanup("myrepo");
}

void test_index_tests__add(void)
{
	git_index *index;
	git_filebuf file = GIT_FILEBUF_INIT;
	git_repository *repo;
	const git_index_entry *entry;
	git_oid id1;

	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);

	/* Create a new file in the working directory */
	cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777));
	cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666));
	cl_git_pass(git_filebuf_write(&file, "hey there\n", 10));
	cl_git_pass(git_filebuf_commit(&file));

	/* 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 */
	cl_git_pass(git_index_add_bypath(index, "test.txt"));

	/* Wow... it worked! */
	cl_assert(git_index_entrycount(index) == 1);
	entry = git_index_get_byindex(index, 0);

	/* And the built-in hashing mechanism worked as expected */
	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);

	/* Test access by path instead of index */
	cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);

	git_index_free(index);
	git_repository_free(repo);
}

static void cleanup_1397(void *opaque)
{
	GIT_UNUSED(opaque);
	cl_git_sandbox_cleanup();
}

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_(git_oid_cmp(&id1, &entry->id) == 0, "first oid check");

	/* 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_(git_oid_cmp(&id1, &entry->id) == 0, "second oid check");

	git_index_free(index);
}

void test_index_tests__add_bypath_to_a_bare_repository_returns_EBAREPO(void)
{
	git_repository *bare_repo;
	git_index *index;

	cl_git_pass(git_repository_open(&bare_repo, cl_fixture("testrepo.git")));
	cl_git_pass(git_repository_index(&index, bare_repo));

	cl_assert_equal_i(GIT_EBAREREPO, git_index_add_bypath(index, "test.txt"));

	git_index_free(index);
	git_repository_free(bare_repo);
}

/* Test that writing an invalid filename fails */
void test_index_tests__write_invalid_filename(void)
{
	git_repository *repo;
	git_index *index;
	git_oid expected;

	p_mkdir("read_tree", 0700);

	cl_git_pass(git_repository_init(&repo, "./read_tree", 0));
	cl_git_pass(git_repository_index(&index, repo));

	cl_assert(git_index_entrycount(index) == 0);

	cl_git_mkfile("./read_tree/.git/hello", NULL);

	cl_git_pass(git_index_add_bypath(index, ".git/hello"));

	/* write-tree */
	cl_git_fail(git_index_write_tree(&expected, index));

	git_index_free(index);
	git_repository_free(repo);

	cl_fixture_cleanup("read_tree");
}

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_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__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_index_tests__elocked(void)
{
	git_repository *repo;
	git_index *index;
	git_filebuf file = GIT_FILEBUF_INIT;
	const git_error *err;
	int error;

	cl_set_cleanup(&cleanup_myrepo, NULL);

	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
	cl_git_pass(git_repository_index(&index, repo));

	/* Lock the index file so we fail to lock it */
	cl_git_pass(git_filebuf_open(&file, index->index_file_path, 0, 0666));
	error = git_index_write(index);
	cl_assert_equal_i(GIT_ELOCKED, error);

	err = giterr_last();
	cl_assert_equal_i(err->klass, GITERR_INDEX);

	git_filebuf_cleanup(&file);
	git_index_free(index);
	git_repository_free(repo);
}

void test_index_tests__reload_from_disk(void)
{
	git_repository *repo;
	git_index *read_index;
	git_index *write_index;

	cl_set_cleanup(&cleanup_myrepo, NULL);

	cl_git_pass(git_futils_mkdir("./myrepo", NULL, 0777, GIT_MKDIR_PATH));
	cl_git_mkfile("./myrepo/a.txt", "a\n");
	cl_git_mkfile("./myrepo/b.txt", "b\n");

	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
	cl_git_pass(git_repository_index(&write_index, repo));
	cl_assert_equal_i(false, write_index->on_disk);

	cl_git_pass(git_index_open(&read_index, write_index->index_file_path));
	cl_assert_equal_i(false, read_index->on_disk);

	/* Stage two new files agaisnt the write_index */
	cl_git_pass(git_index_add_bypath(write_index, "a.txt"));
	cl_git_pass(git_index_add_bypath(write_index, "b.txt"));

	cl_assert_equal_sz(2, git_index_entrycount(write_index));

	/* Persist the index changes to disk */
	cl_git_pass(git_index_write(write_index));
	cl_assert_equal_i(true, write_index->on_disk);

	/* Sync the changes back into the read_index */
	cl_assert_equal_sz(0, git_index_entrycount(read_index));

	cl_git_pass(git_index_read(read_index, true));
	cl_assert_equal_i(true, read_index->on_disk);

	cl_assert_equal_sz(2, git_index_entrycount(read_index));

	/* Remove the index file from the filesystem */
	cl_git_pass(p_unlink(write_index->index_file_path));

	/* Sync the changes back into the read_index */
	cl_git_pass(git_index_read(read_index, true));
	cl_assert_equal_i(false, read_index->on_disk);
	cl_assert_equal_sz(0, git_index_entrycount(read_index));

	git_index_free(read_index);
	git_index_free(write_index);
	git_repository_free(repo);
}

void test_index_tests__corrupted_extension(void)
{
	git_index *index;

	cl_git_fail_with(git_index_open(&index, TEST_INDEXBAD_PATH), GIT_ERROR);
}

static void assert_index_is_sorted(git_index *index)
{
	git_vector *entries = &index->entries;
	size_t i;

	cl_assert(git_vector_is_sorted(entries));

	for (i = 1; i < git_vector_length(entries); ++i) {
		git_index_entry *prev = git_vector_get(entries, i - 1);
		git_index_entry *curr = git_vector_get(entries, i);
		cl_assert(index->entries._cmp(prev, curr) <= 0);
	}
}

void test_index_tests__reload_while_ignoring_case(void)
{
	git_index *index;
	unsigned int caps;

	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
	assert_index_is_sorted(index);

	caps = git_index_caps(index);
	cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEXCAP_IGNORE_CASE));
	cl_git_pass(git_index_read(index, true));
	assert_index_is_sorted(index);

	cl_git_pass(git_index_set_caps(index, caps | GIT_INDEXCAP_IGNORE_CASE));
	cl_git_pass(git_index_read(index, true));
	assert_index_is_sorted(index);

	git_index_free(index);
}
Commit	Line	Data
6c106eec BS	1	#include "clar_libgit2.h"
	2	#include "index.h"
	3
a8122b5d RB	4	static const size_t index_entry_count = 109;
a8122b5d RB	5	static const size_t index_entry_count_2 = 1437;
6c106eec BS	6	#define TEST_INDEX_PATH cl_fixture("testrepo.git/index")
	7	#define TEST_INDEX2_PATH cl_fixture("gitgit.index")
	8	#define TEST_INDEXBIG_PATH cl_fixture("big.index")
3d523345	9	#define TEST_INDEXBAD_PATH cl_fixture("bad.index")
6c106eec BS	10
6c106eec BS	11
8e5a8ef8	12	/* Suite data */
6c106eec	13	struct test_entry {
11d9f6b3	14	size_t index;
6c106eec BS	15	char path[128];
	16	git_off_t file_size;
	17	git_time_t mtime;
	18	};
	19
b482c420	20	static struct test_entry test_entries[] = {
6c106eec BS	21	{4, "Makefile", 5064, 0x4C3F7F33},
	22	{62, "tests/Makefile", 2631, 0x4C3F7F33},
	23	{36, "src/index.c", 10014, 0x4C43368D},
	24	{6, "git.git-authors", 2709, 0x4C3F7F33},
	25	{48, "src/revobject.h", 1448, 0x4C3F7FE2}
	26	};
	27
8e5a8ef8	28	/* Helpers */
270303ca	29	static void copy_file(const char src, const char dst)
6c106eec BS	30	{
	31	git_buf source_buf = GIT_BUF_INIT;
	32	git_file dst_fd;
6c106eec	33
270303ca	34	cl_git_pass(git_futils_readbuffer(&source_buf, src));
6c106eec	35
8e5a8ef8	36	dst_fd = git_futils_creat_withpath(dst, 0777, 0666); /* -V536 */
6c106eec BS	37	if (dst_fd < 0)
	38	goto cleanup;
	39
270303ca	40	cl_git_pass(p_write(dst_fd, source_buf.ptr, source_buf.size));
6c106eec BS	41
	42	cleanup:
	43	git_buf_free(&source_buf);
	44	p_close(dst_fd);
6c106eec BS	45	}
6c106eec BS	46
270303ca	47	static void files_are_equal(const char a, const char b)
6c106eec BS	48	{
	49	git_buf buf_a = GIT_BUF_INIT;
	50	git_buf buf_b = GIT_BUF_INIT;
270303ca	51	int pass;
6c106eec	52
e172cf08	53	if (git_futils_readbuffer(&buf_a, a) < 0)
270303ca	54	cl_assert(0);
6c106eec	55
e172cf08	56	if (git_futils_readbuffer(&buf_b, b) < 0) {
6c106eec	57	git_buf_free(&buf_a);
270303ca	58	cl_assert(0);
6c106eec BS	59	}
6c106eec BS	60
270303ca	61	pass = (buf_a.size == buf_b.size && !memcmp(buf_a.ptr, buf_b.ptr, buf_a.size));
6c106eec BS	62
	63	git_buf_free(&buf_a);
	64	git_buf_free(&buf_b);
13ed2966 MS	65
13ed2966 MS	66	cl_assert(pass);
6c106eec BS	67	}
	68
	69
8e5a8ef8	70	/* Fixture setup and teardown */
6c106eec BS	71	void test_index_tests__initialize(void)
	72	{
	73	}
	74
6c106eec BS	75	void test_index_tests__empty_index(void)
	76	{
	77	git_index *index;
	78
	79	cl_git_pass(git_index_open(&index, "in-memory-index"));
	80	cl_assert(index->on_disk == 0);
	81
	82	cl_assert(git_index_entrycount(index) == 0);
882c7742	83	cl_assert(git_vector_is_sorted(&index->entries));
6c106eec BS	84
	85	git_index_free(index);
	86	}
	87
	88	void test_index_tests__default_test_index(void)
	89	{
	90	git_index *index;
	91	unsigned int i;
	92	git_index_entry **entries;
	93
	94	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
	95	cl_assert(index->on_disk);
	96
a8122b5d	97	cl_assert(git_index_entrycount(index) == index_entry_count);
882c7742	98	cl_assert(git_vector_is_sorted(&index->entries));
6c106eec BS	99
	100	entries = (git_index_entry **)index->entries.contents;
	101
b482c420	102	for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
34b8eafc	103	git_index_entry *e = entries[test_entries[i].index];
6c106eec	104
34b8eafc	105	cl_assert_equal_s(e->path, test_entries[i].path);
	106	cl_assert(e->mtime.seconds == test_entries[i].mtime);
	107	cl_assert(e->file_size == test_entries[i].file_size);
6c106eec BS	108	}
	109
	110	git_index_free(index);
	111	}
	112
	113	void test_index_tests__gitgit_index(void)
	114	{
	115	git_index *index;
	116
	117	cl_git_pass(git_index_open(&index, TEST_INDEX2_PATH));
	118	cl_assert(index->on_disk);
	119
a8122b5d	120	cl_assert(git_index_entrycount(index) == index_entry_count_2);
882c7742	121	cl_assert(git_vector_is_sorted(&index->entries));
6c106eec BS	122	cl_assert(index->tree != NULL);
	123
	124	git_index_free(index);
	125	}
	126
	127	void test_index_tests__find_in_existing(void)
	128	{
	129	git_index *index;
	130	unsigned int i;
	131
	132	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
	133
b482c420	134	for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
34b8eafc	135	size_t idx;
11d9f6b3	136
34b8eafc	137	cl_assert(!git_index_find(&idx, index, test_entries[i].path));
34b8eafc	138	cl_assert(idx == test_entries[i].index);
6c106eec BS	139	}
	140
	141	git_index_free(index);
	142	}
	143
	144	void test_index_tests__find_in_empty(void)
	145	{
	146	git_index *index;
	147	unsigned int i;
	148
	149	cl_git_pass(git_index_open(&index, "fake-index"));
	150
b482c420	151	for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
34b8eafc	152	cl_assert(GIT_ENOTFOUND == git_index_find(NULL, index, test_entries[i].path));
6c106eec BS	153	}
	154
	155	git_index_free(index);
	156	}
	157
	158	void test_index_tests__write(void)
	159	{
	160	git_index *index;
	161
270303ca	162	copy_file(TEST_INDEXBIG_PATH, "index_rewrite");
6c106eec BS	163
	164	cl_git_pass(git_index_open(&index, "index_rewrite"));
	165	cl_assert(index->on_disk);
	166
	167	cl_git_pass(git_index_write(index));
270303ca	168	files_are_equal(TEST_INDEXBIG_PATH, "index_rewrite");
6c106eec BS	169
	170	git_index_free(index);
	171
	172	p_unlink("index_rewrite");
	173	}
	174
	175	void test_index_tests__sort0(void)
	176	{
8e5a8ef8 RB	177	/* sort the entires in an index */
8e5a8ef8 RB	178
6c106eec BS	179	/*
	180	* TODO: This no longer applies:
	181	* index sorting in Git uses some specific changes to the way
	182	* directories are sorted.
	183	*
	184	* We need to specificially check for this by creating a new
	185	* index, adding entries in random order and then
	186	* checking for consistency
	187	*/
	188	}
	189
	190	void test_index_tests__sort1(void)
	191	{
8e5a8ef8	192	/* sort the entires in an empty index */
6c106eec BS	193	git_index *index;
	194
	195	cl_git_pass(git_index_open(&index, "fake-index"));
	196
	197	/* FIXME: this test is slightly dumb */
882c7742	198	cl_assert(git_vector_is_sorted(&index->entries));
6c106eec BS	199
	200	git_index_free(index);
	201	}
	202
f6fded8f VM	203	static void cleanup_myrepo(void *opaque)
	204	{
	205	GIT_UNUSED(opaque);
	206	cl_fixture_cleanup("myrepo");
	207	}
	208
6c106eec BS	209	void test_index_tests__add(void)
6c106eec BS	210	{
f6fded8f VM	211	git_index *index;
	212	git_filebuf file = GIT_FILEBUF_INIT;
	213	git_repository *repo;
	214	const git_index_entry *entry;
	215	git_oid id1;
6c106eec	216
f6fded8f	217	cl_set_cleanup(&cleanup_myrepo, NULL);
6c106eec	218
f6fded8f VM	219	/* Intialize a new repository */
f6fded8f VM	220	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
6c106eec	221
f6fded8f VM	222	/* Ensure we're the only guy in the room */
	223	cl_git_pass(git_repository_index(&index, repo));
	224	cl_assert(git_index_entrycount(index) == 0);
6c106eec	225
f6fded8f VM	226	/* Create a new file in the working directory */
f6fded8f VM	227	cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777));
1d3a8aeb	228	cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666));
f6fded8f	229	cl_git_pass(git_filebuf_write(&file, "hey there\n", 10));
1d3a8aeb	230	cl_git_pass(git_filebuf_commit(&file));
6c106eec	231
f6fded8f VM	232	/* Store the expected hash of the file/blob
	233	* This has been generated by executing the following
	234	* $ echo "hey there" \| git hash-object --stdin
	235	*/
	236	cl_git_pass(git_oid_fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6"));
6c106eec	237
f6fded8f	238	/* Add the new file to the index */
25743bd7	239	cl_git_pass(git_index_add_bypath(index, "test.txt"));
6c106eec	240
f6fded8f VM	241	/* Wow... it worked! */
	242	cl_assert(git_index_entrycount(index) == 1);
	243	entry = git_index_get_byindex(index, 0);
6c106eec	244
f6fded8f	245	/* And the built-in hashing mechanism worked as expected */
d541170c	246	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);
f45ec1a0	247
f6fded8f VM	248	/* Test access by path instead of index */
f6fded8f VM	249	cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
d541170c	250	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);
f6fded8f VM	251
	252	git_index_free(index);
	253	git_repository_free(repo);
6c106eec BS	254	}
6c106eec BS	255
1098cfae RB	256	static void cleanup_1397(void *opaque)
	257	{
	258	GIT_UNUSED(opaque);
	259	cl_git_sandbox_cleanup();
	260	}
	261
b8acb775 SS	262	void test_index_tests__add_issue_1397(void)
	263	{
	264	git_index *index;
b8acb775 SS	265	git_repository *repo;
	266	const git_index_entry *entry;
	267	git_oid id1;
	268
1098cfae	269	cl_set_cleanup(&cleanup_1397, NULL);
b8acb775 SS	270
	271	repo = cl_git_sandbox_init("issue_1397");
	272
1098cfae	273	cl_repo_set_bool(repo, "core.autocrlf", true);
b8acb775 SS	274
	275	/* Ensure we're the only guy in the room */
	276	cl_git_pass(git_repository_index(&index, repo));
	277
	278	/* Store the expected hash of the file/blob
	279	* This has been generated by executing the following
	280	* $ git hash-object crlf_file.txt
	281	*/
	282	cl_git_pass(git_oid_fromstr(&id1, "8312e0889a9cbab77c732b6bc39b51a683e3a318"));
	283
	284	/* Make sure the initial SHA-1 is correct */
	285	cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL);
d541170c	286	cl_assert_(git_oid_cmp(&id1, &entry->id) == 0, "first oid check");
b8acb775 SS	287
	288	/* Update the index */
	289	cl_git_pass(git_index_add_bypath(index, "crlf_file.txt"));
	290
	291	/* Check the new SHA-1 */
	292	cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL);
d541170c	293	cl_assert_(git_oid_cmp(&id1, &entry->id) == 0, "second oid check");
b8acb775 SS	294
b8acb775 SS	295	git_index_free(index);
b8acb775 SS	296	}
b8acb775 SS	297
25743bd7	298	void test_index_tests__add_bypath_to_a_bare_repository_returns_EBAREPO(void)
33f95a9b	299	{
	300	git_repository *bare_repo;
	301	git_index *index;
	302
	303	cl_git_pass(git_repository_open(&bare_repo, cl_fixture("testrepo.git")));
	304	cl_git_pass(git_repository_index(&index, bare_repo));
	305
25743bd7	306	cl_assert_equal_i(GIT_EBAREREPO, git_index_add_bypath(index, "test.txt"));
33f95a9b	307
	308	git_index_free(index);
	309	git_repository_free(bare_repo);
	310	}
1876360f SG	311
	312	/* Test that writing an invalid filename fails */
	313	void test_index_tests__write_invalid_filename(void)
	314	{
	315	git_repository *repo;
	316	git_index *index;
	317	git_oid expected;
	318
	319	p_mkdir("read_tree", 0700);
	320
	321	cl_git_pass(git_repository_init(&repo, "./read_tree", 0));
	322	cl_git_pass(git_repository_index(&index, repo));
	323
	324	cl_assert(git_index_entrycount(index) == 0);
	325
	326	cl_git_mkfile("./read_tree/.git/hello", NULL);
	327
25743bd7	328	cl_git_pass(git_index_add_bypath(index, ".git/hello"));
1876360f SG	329
	330	/* write-tree */
	331	cl_git_fail(git_index_write_tree(&expected, index));
	332
	333	git_index_free(index);
	334	git_repository_free(repo);
	335
	336	cl_fixture_cleanup("read_tree");
	337	}
7fc00435 RB	338
	339	void test_index_tests__remove_entry(void)
	340	{
	341	git_repository *repo;
	342	git_index *index;
	343
	344	p_mkdir("index_test", 0770);
	345
	346	cl_git_pass(git_repository_init(&repo, "index_test", 0));
	347	cl_git_pass(git_repository_index(&index, repo));
	348	cl_assert(git_index_entrycount(index) == 0);
	349
	350	cl_git_mkfile("index_test/hello", NULL);
25743bd7	351	cl_git_pass(git_index_add_bypath(index, "hello"));
7fc00435 RB	352	cl_git_pass(git_index_write(index));
7fc00435 RB	353
8e5a8ef8	354	cl_git_pass(git_index_read(index, true)); /* reload */
7fc00435 RB	355	cl_assert(git_index_entrycount(index) == 1);
	356	cl_assert(git_index_get_bypath(index, "hello", 0) != NULL);
	357
	358	cl_git_pass(git_index_remove(index, "hello", 0));
	359	cl_git_pass(git_index_write(index));
	360
8e5a8ef8	361	cl_git_pass(git_index_read(index, true)); /* reload */
7fc00435 RB	362	cl_assert(git_index_entrycount(index) == 0);
	363	cl_assert(git_index_get_bypath(index, "hello", 0) == NULL);
	364
	365	git_index_free(index);
	366	git_repository_free(repo);
	367	cl_fixture_cleanup("index_test");
	368	}
	369
	370	void test_index_tests__remove_directory(void)
	371	{
	372	git_repository *repo;
	373	git_index *index;
	374
	375	p_mkdir("index_test", 0770);
	376
	377	cl_git_pass(git_repository_init(&repo, "index_test", 0));
	378	cl_git_pass(git_repository_index(&index, repo));
	379	cl_assert_equal_i(0, (int)git_index_entrycount(index));
	380
	381	p_mkdir("index_test/a", 0770);
	382	cl_git_mkfile("index_test/a/1.txt", NULL);
	383	cl_git_mkfile("index_test/a/2.txt", NULL);
	384	cl_git_mkfile("index_test/a/3.txt", NULL);
	385	cl_git_mkfile("index_test/b.txt", NULL);
	386
25743bd7 ET	387	cl_git_pass(git_index_add_bypath(index, "a/1.txt"));
	388	cl_git_pass(git_index_add_bypath(index, "a/2.txt"));
	389	cl_git_pass(git_index_add_bypath(index, "a/3.txt"));
	390	cl_git_pass(git_index_add_bypath(index, "b.txt"));
7fc00435 RB	391	cl_git_pass(git_index_write(index));
7fc00435 RB	392
8e5a8ef8	393	cl_git_pass(git_index_read(index, true)); /* reload */
7fc00435 RB	394	cl_assert_equal_i(4, (int)git_index_entrycount(index));
	395	cl_assert(git_index_get_bypath(index, "a/1.txt", 0) != NULL);
	396	cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL);
	397	cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
	398
	399	cl_git_pass(git_index_remove(index, "a/1.txt", 0));
	400	cl_git_pass(git_index_write(index));
	401
8e5a8ef8	402	cl_git_pass(git_index_read(index, true)); /* reload */
7fc00435 RB	403	cl_assert_equal_i(3, (int)git_index_entrycount(index));
	404	cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL);
	405	cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL);
	406	cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
	407
	408	cl_git_pass(git_index_remove_directory(index, "a", 0));
	409	cl_git_pass(git_index_write(index));
	410
8e5a8ef8	411	cl_git_pass(git_index_read(index, true)); /* reload */
7fc00435 RB	412	cl_assert_equal_i(1, (int)git_index_entrycount(index));
	413	cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL);
	414	cl_assert(git_index_get_bypath(index, "a/2.txt", 0) == NULL);
	415	cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
	416
	417	git_index_free(index);
	418	git_repository_free(repo);
	419	cl_fixture_cleanup("index_test");
	420	}
1540b199 ET	421
	422	void test_index_tests__preserves_case(void)
	423	{
	424	git_repository *repo;
	425	git_index *index;
	426	const git_index_entry *entry;
fb03a223	427	int index_caps;
1540b199 ET	428
	429	cl_set_cleanup(&cleanup_myrepo, NULL);
	430
	431	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
	432	cl_git_pass(git_repository_index(&index, repo));
	433
fb03a223 RB	434	index_caps = git_index_caps(index);
fb03a223 RB	435
1540b199 ET	436	cl_git_rewritefile("myrepo/test.txt", "hey there\n");
	437	cl_git_pass(git_index_add_bypath(index, "test.txt"));
	438
	439	cl_git_pass(p_rename("myrepo/test.txt", "myrepo/TEST.txt"));
	440	cl_git_rewritefile("myrepo/TEST.txt", "hello again\n");
	441	cl_git_pass(git_index_add_bypath(index, "TEST.txt"));
	442
fb03a223 RB	443	if (index_caps & GIT_INDEXCAP_IGNORE_CASE)
	444	cl_assert_equal_i(1, (int)git_index_entrycount(index));
	445	else
	446	cl_assert_equal_i(2, (int)git_index_entrycount(index));
1540b199 ET	447
	448	/* Test access by path instead of index */
	449	cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
1540b199 ET	450	/* The path should not have changed without an explicit remove */
	451	cl_assert(git__strcmp(entry->path, "test.txt") == 0);
	452
fb03a223 RB	453	cl_assert((entry = git_index_get_bypath(index, "TEST.txt", 0)) != NULL);
	454	if (index_caps & GIT_INDEXCAP_IGNORE_CASE)
	455	/* The path should not have changed without an explicit remove */
	456	cl_assert(git__strcmp(entry->path, "test.txt") == 0);
	457	else
	458	cl_assert(git__strcmp(entry->path, "TEST.txt") == 0);
	459
1540b199 ET	460	git_index_free(index);
	461	git_repository_free(repo);
	462	}
	463
3d276874 CMN	464	void test_index_tests__elocked(void)
	465	{
	466	git_repository *repo;
	467	git_index *index;
	468	git_filebuf file = GIT_FILEBUF_INIT;
	469	const git_error *err;
	470	int error;
	471
	472	cl_set_cleanup(&cleanup_myrepo, NULL);
	473
	474	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
	475	cl_git_pass(git_repository_index(&index, repo));
	476
	477	/* Lock the index file so we fail to lock it */
1d3a8aeb	478	cl_git_pass(git_filebuf_open(&file, index->index_file_path, 0, 0666));
3d276874 CMN	479	error = git_index_write(index);
	480	cl_assert_equal_i(GIT_ELOCKED, error);
	481
	482	err = giterr_last();
	483	cl_assert_equal_i(err->klass, GITERR_INDEX);
	484
	485	git_filebuf_cleanup(&file);
	486	git_index_free(index);
	487	git_repository_free(repo);
	488	}
da7b78fa	489
	490	void test_index_tests__reload_from_disk(void)
	491	{
	492	git_repository *repo;
	493	git_index *read_index;
	494	git_index *write_index;
	495
	496	cl_set_cleanup(&cleanup_myrepo, NULL);
	497
	498	cl_git_pass(git_futils_mkdir("./myrepo", NULL, 0777, GIT_MKDIR_PATH));
	499	cl_git_mkfile("./myrepo/a.txt", "a\n");
	500	cl_git_mkfile("./myrepo/b.txt", "b\n");
	501
	502	cl_git_pass(git_repository_init(&repo, "./myrepo", 0));
	503	cl_git_pass(git_repository_index(&write_index, repo));
	504	cl_assert_equal_i(false, write_index->on_disk);
	505
	506	cl_git_pass(git_index_open(&read_index, write_index->index_file_path));
	507	cl_assert_equal_i(false, read_index->on_disk);
	508
	509	/* Stage two new files agaisnt the write_index */
	510	cl_git_pass(git_index_add_bypath(write_index, "a.txt"));
	511	cl_git_pass(git_index_add_bypath(write_index, "b.txt"));
	512
	513	cl_assert_equal_sz(2, git_index_entrycount(write_index));
	514
	515	/* Persist the index changes to disk */
	516	cl_git_pass(git_index_write(write_index));
	517	cl_assert_equal_i(true, write_index->on_disk);
	518
	519	/* Sync the changes back into the read_index */
	520	cl_assert_equal_sz(0, git_index_entrycount(read_index));
	521
8e5a8ef8	522	cl_git_pass(git_index_read(read_index, true));
da7b78fa	523	cl_assert_equal_i(true, read_index->on_disk);
	524
	525	cl_assert_equal_sz(2, git_index_entrycount(read_index));
	526
	527	/* Remove the index file from the filesystem */
	528	cl_git_pass(p_unlink(write_index->index_file_path));
	529
	530	/* Sync the changes back into the read_index */
8e5a8ef8	531	cl_git_pass(git_index_read(read_index, true));
da7b78fa	532	cl_assert_equal_i(false, read_index->on_disk);
	533	cl_assert_equal_sz(0, git_index_entrycount(read_index));
	534
	535	git_index_free(read_index);
	536	git_index_free(write_index);
	537	git_repository_free(repo);
	538	}
3d523345	539
	540	void test_index_tests__corrupted_extension(void)
	541	{
3d523345	542	git_index *index;
	543
	544	cl_git_fail_with(git_index_open(&index, TEST_INDEXBAD_PATH), GIT_ERROR);
	545	}
43709ca8 RB	546
	547	static void assert_index_is_sorted(git_index *index)
	548	{
	549	git_vector *entries = &index->entries;
	550	size_t i;
	551
	552	cl_assert(git_vector_is_sorted(entries));
	553
	554	for (i = 1; i < git_vector_length(entries); ++i) {
	555	git_index_entry *prev = git_vector_get(entries, i - 1);
	556	git_index_entry *curr = git_vector_get(entries, i);
	557	cl_assert(index->entries._cmp(prev, curr) <= 0);
	558	}
	559	}
	560
	561	void test_index_tests__reload_while_ignoring_case(void)
	562	{
	563	git_index *index;
	564	unsigned int caps;
	565
	566	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
	567	assert_index_is_sorted(index);
	568
	569	caps = git_index_caps(index);
	570	cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEXCAP_IGNORE_CASE));
	571	cl_git_pass(git_index_read(index, true));
	572	assert_index_is_sorted(index);
	573
	574	cl_git_pass(git_index_set_caps(index, caps \| GIT_INDEXCAP_IGNORE_CASE));
	575	cl_git_pass(git_index_read(index, true));
	576	assert_index_is_sorted(index);
	577
	578	git_index_free(index);
	579	}