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

#include "clar_libgit2.h"
#include "index.h"
#include "git2/sys/index.h"
#include "git2/repository.h"
#include "../reset/reset_helpers.h"

static git_repository *repo;
static git_index *repo_index;

#define TEST_REPO_PATH "mergedrepo"
#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"

#define ONE_ANCESTOR_OID "478871385b9cd03908c5383acfd568bef023c6b3"
#define ONE_OUR_OID "4458b8bc9e72b6c8755ae456f60e9844d0538d8c"
#define ONE_THEIR_OID "8b72416545c7e761b64cecad4f1686eae4078aa8"

#define TWO_ANCESTOR_OID "9d81f82fccc7dcd7de7a1ffead1815294c2e092c"
#define TWO_OUR_OID "8f3c06cff9a83757cec40c80bc9bf31a2582bde9"
#define TWO_THEIR_OID "887b153b165d32409c70163e0f734c090f12f673"

// Fixture setup and teardown
void test_index_reuc__initialize(void)
{
	repo = cl_git_sandbox_init("mergedrepo");
	git_repository_index(&repo_index, repo);
}

void test_index_reuc__cleanup(void)
{
	git_index_free(repo_index);
	repo_index = NULL;

	cl_git_sandbox_cleanup();
}

void test_index_reuc__add(void)
{
	git_oid ancestor_oid, our_oid, their_oid;
	const git_index_reuc_entry *reuc;

	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	git_oid_fromstr(&their_oid, ONE_THEIR_OID);

	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
		0100644, &ancestor_oid,
		0100644, &our_oid,
		0100644, &their_oid));

	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));

	cl_assert_equal_s("newfile.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
}

void test_index_reuc__add_no_ancestor(void)
{
	git_oid ancestor_oid, our_oid, their_oid;
	const git_index_reuc_entry *reuc;

	memset(&ancestor_oid, 0x0, sizeof(git_oid));
	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	git_oid_fromstr(&their_oid, ONE_THEIR_OID);

	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
		0, NULL,
		0100644, &our_oid,
		0100644, &their_oid));

	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));

	cl_assert_equal_s("newfile.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
}

void test_index_reuc__read_bypath(void)
{
	const git_index_reuc_entry *reuc;
	git_oid oid;

	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));

	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "two.txt"));

	cl_assert_equal_s("two.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, TWO_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, TWO_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);

	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "one.txt"));

	cl_assert_equal_s("one.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, ONE_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, ONE_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}

void test_index_reuc__ignore_case(void)
{
	const git_index_reuc_entry *reuc;
	git_oid oid;
	int index_caps;

	index_caps = git_index_caps(repo_index);

	index_caps &= ~GIT_INDEXCAP_IGNORE_CASE;
	cl_git_pass(git_index_set_caps(repo_index, index_caps));

	cl_assert(!git_index_reuc_get_bypath(repo_index, "TWO.txt"));

	index_caps |= GIT_INDEXCAP_IGNORE_CASE;
	cl_git_pass(git_index_set_caps(repo_index, index_caps));

	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));

	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "TWO.txt"));

	cl_assert_equal_s("two.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, TWO_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, TWO_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}

void test_index_reuc__read_byindex(void)
{
	const git_index_reuc_entry *reuc;
	git_oid oid;

	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));

	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));

	cl_assert_equal_s("one.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, ONE_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, ONE_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);

	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));

	cl_assert_equal_s("two.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, TWO_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, TWO_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}

void test_index_reuc__updates_existing(void)
{
	const git_index_reuc_entry *reuc;
	git_oid ancestor_oid, our_oid, their_oid, oid;
	int index_caps;

	git_index_clear(repo_index);

	index_caps = git_index_caps(repo_index);

	index_caps |= GIT_INDEXCAP_IGNORE_CASE;
	cl_git_pass(git_index_set_caps(repo_index, index_caps));

	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	git_oid_fromstr(&their_oid, TWO_THEIR_OID);

	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
		0100644, &ancestor_oid,
		0100644, &our_oid,
		0100644, &their_oid));

	cl_git_pass(git_index_reuc_add(repo_index, "TWO.txt",
		0100644, &our_oid,
		0100644, &their_oid,
		0100644, &ancestor_oid));

	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));

	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));

	cl_assert_equal_s("TWO.txt", reuc->path);
	git_oid_fromstr(&oid, TWO_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, TWO_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}

void test_index_reuc__remove(void)
{
	git_oid oid;
	const git_index_reuc_entry *reuc;

	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));

	cl_git_pass(git_index_reuc_remove(repo_index, 0));
	cl_git_fail(git_index_reuc_remove(repo_index, 1));

	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));

	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));

	cl_assert_equal_s("two.txt", reuc->path);
	cl_assert(reuc->mode[0] == 0100644);
	cl_assert(reuc->mode[1] == 0100644);
	cl_assert(reuc->mode[2] == 0100644);
	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	git_oid_fromstr(&oid, TWO_OUR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	git_oid_fromstr(&oid, TWO_THEIR_OID);
	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}

void test_index_reuc__write(void)
{
	git_oid ancestor_oid, our_oid, their_oid;
	const git_index_reuc_entry *reuc;

	git_index_clear(repo_index);

	/* Write out of order to ensure sorting is correct */
	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	git_oid_fromstr(&their_oid, TWO_THEIR_OID);

	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
		0100644, &ancestor_oid,
		0100644, &our_oid,
		0100644, &their_oid));

	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	git_oid_fromstr(&their_oid, ONE_THEIR_OID);

	cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
		0100644, &ancestor_oid,
		0100644, &our_oid,
		0100644, &their_oid));

	cl_git_pass(git_index_write(repo_index));
	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));

	/* ensure sort order was round-tripped correct */
	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	cl_assert_equal_s("one.txt", reuc->path);

	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
	cl_assert_equal_s("two.txt", reuc->path);
}

static int reuc_entry_exists(void)
{
	return (git_index_reuc_get_bypath(repo_index, "newfile.txt") != NULL);
}

void test_index_reuc__cleaned_on_reset_hard(void)
{
	git_object *target;

	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));

	test_index_reuc__add();
	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
	cl_assert(reuc_entry_exists() == false);

	git_object_free(target);
}

void test_index_reuc__cleaned_on_reset_mixed(void)
{
	git_object *target;

	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));

	test_index_reuc__add();
	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
	cl_assert(reuc_entry_exists() == false);

	git_object_free(target);
}

void test_index_reuc__retained_on_reset_soft(void)
{
	git_object *target;

	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));

	git_reset(repo, target, GIT_RESET_HARD, NULL, NULL);

	test_index_reuc__add();
	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
	cl_assert(reuc_entry_exists() == true);

	git_object_free(target);
}

void test_index_reuc__cleaned_on_checkout_tree(void)
{
	git_oid oid;
	git_object *obj;
	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;

	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;

	test_index_reuc__add();
	git_reference_name_to_id(&oid, repo, "refs/heads/master");
	git_object_lookup(&obj, repo, &oid, GIT_OBJ_ANY);
	git_checkout_tree(repo, obj, &opts);
	cl_assert(reuc_entry_exists() == false);

	git_object_free(obj);
}

void test_index_reuc__cleaned_on_checkout_head(void)
{
	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;

	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;

	test_index_reuc__add();
	git_checkout_head(repo, &opts);
	cl_assert(reuc_entry_exists() == false);
}

void test_index_reuc__retained_on_checkout_index(void)
{
	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;

	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;

	test_index_reuc__add();
	git_checkout_index(repo, repo_index, &opts);
	cl_assert(reuc_entry_exists() == true);
}
Commit	Line	Data
f45ec1a0 ET	1	#include "clar_libgit2.h"
f45ec1a0 ET	2	#include "index.h"
75d1c8c6	3	#include "git2/sys/index.h"
f45ec1a0	4	#include "git2/repository.h"
5bddabcc	5	#include "../reset/reset_helpers.h"
f45ec1a0 ET	6
	7	static git_repository *repo;
	8	static git_index *repo_index;
	9
	10	#define TEST_REPO_PATH "mergedrepo"
	11	#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
	12
	13	#define ONE_ANCESTOR_OID "478871385b9cd03908c5383acfd568bef023c6b3"
	14	#define ONE_OUR_OID "4458b8bc9e72b6c8755ae456f60e9844d0538d8c"
	15	#define ONE_THEIR_OID "8b72416545c7e761b64cecad4f1686eae4078aa8"
	16
	17	#define TWO_ANCESTOR_OID "9d81f82fccc7dcd7de7a1ffead1815294c2e092c"
	18	#define TWO_OUR_OID "8f3c06cff9a83757cec40c80bc9bf31a2582bde9"
	19	#define TWO_THEIR_OID "887b153b165d32409c70163e0f734c090f12f673"
	20
	21	// Fixture setup and teardown
	22	void test_index_reuc__initialize(void)
	23	{
	24	repo = cl_git_sandbox_init("mergedrepo");
	25	git_repository_index(&repo_index, repo);
	26	}
	27
	28	void test_index_reuc__cleanup(void)
	29	{
	30	git_index_free(repo_index);
9094d30b SC	31	repo_index = NULL;
9094d30b SC	32
f45ec1a0 ET	33	cl_git_sandbox_cleanup();
	34	}
	35
eb3c247a ET	36	void test_index_reuc__add(void)
	37	{
	38	git_oid ancestor_oid, our_oid, their_oid;
	39	const git_index_reuc_entry *reuc;
	40
	41	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	42	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	43	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	44
	45	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
	46	0100644, &ancestor_oid,
	47	0100644, &our_oid,
	48	0100644, &their_oid));
	49
	50	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
	51
a7f8065f	52	cl_assert_equal_s("newfile.txt", reuc->path);
eb3c247a ET	53	cl_assert(reuc->mode[0] == 0100644);
	54	cl_assert(reuc->mode[1] == 0100644);
	55	cl_assert(reuc->mode[2] == 0100644);
	56	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	57	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	58	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
	59	}
	60
	61	void test_index_reuc__add_no_ancestor(void)
	62	{
	63	git_oid ancestor_oid, our_oid, their_oid;
	64	const git_index_reuc_entry *reuc;
	65
	66	memset(&ancestor_oid, 0x0, sizeof(git_oid));
	67	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	68	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	69
	70	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
	71	0, NULL,
	72	0100644, &our_oid,
	73	0100644, &their_oid));
	74
	75	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
	76
a7f8065f	77	cl_assert_equal_s("newfile.txt", reuc->path);
eb3c247a ET	78	cl_assert(reuc->mode[0] == 0);
	79	cl_assert(reuc->mode[1] == 0100644);
	80	cl_assert(reuc->mode[2] == 0100644);
	81	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	82	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	83	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
	84	}
	85
f45ec1a0 ET	86	void test_index_reuc__read_bypath(void)
	87	{
	88	const git_index_reuc_entry *reuc;
	89	git_oid oid;
	90
	91	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	92
	93	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "two.txt"));
	94
a7f8065f	95	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	96	cl_assert(reuc->mode[0] == 0100644);
	97	cl_assert(reuc->mode[1] == 0100644);
	98	cl_assert(reuc->mode[2] == 0100644);
	99	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	100	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	101	git_oid_fromstr(&oid, TWO_OUR_OID);
	102	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	103	git_oid_fromstr(&oid, TWO_THEIR_OID);
	104	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	105
	106	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "one.txt"));
	107
a7f8065f	108	cl_assert_equal_s("one.txt", reuc->path);
f45ec1a0 ET	109	cl_assert(reuc->mode[0] == 0100644);
	110	cl_assert(reuc->mode[1] == 0100644);
	111	cl_assert(reuc->mode[2] == 0100644);
	112	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	113	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	114	git_oid_fromstr(&oid, ONE_OUR_OID);
	115	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	116	git_oid_fromstr(&oid, ONE_THEIR_OID);
	117	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	118	}
	119
	120	void test_index_reuc__ignore_case(void)
	121	{
	122	const git_index_reuc_entry *reuc;
	123	git_oid oid;
	124	int index_caps;
	125
	126	index_caps = git_index_caps(repo_index);
	127
	128	index_caps &= ~GIT_INDEXCAP_IGNORE_CASE;
	129	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	130
	131	cl_assert(!git_index_reuc_get_bypath(repo_index, "TWO.txt"));
	132
	133	index_caps \|= GIT_INDEXCAP_IGNORE_CASE;
	134	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	135
	136	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	137
	138	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "TWO.txt"));
	139
a7f8065f	140	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	141	cl_assert(reuc->mode[0] == 0100644);
	142	cl_assert(reuc->mode[1] == 0100644);
	143	cl_assert(reuc->mode[2] == 0100644);
	144	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	145	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	146	git_oid_fromstr(&oid, TWO_OUR_OID);
	147	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	148	git_oid_fromstr(&oid, TWO_THEIR_OID);
	149	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	150	}
	151
	152	void test_index_reuc__read_byindex(void)
	153	{
	154	const git_index_reuc_entry *reuc;
	155	git_oid oid;
	156
	157	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	158
	159	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	160
a7f8065f	161	cl_assert_equal_s("one.txt", reuc->path);
f45ec1a0 ET	162	cl_assert(reuc->mode[0] == 0100644);
	163	cl_assert(reuc->mode[1] == 0100644);
	164	cl_assert(reuc->mode[2] == 0100644);
	165	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	166	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	167	git_oid_fromstr(&oid, ONE_OUR_OID);
	168	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	169	git_oid_fromstr(&oid, ONE_THEIR_OID);
	170	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	171
	172	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
	173
a7f8065f	174	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	175	cl_assert(reuc->mode[0] == 0100644);
	176	cl_assert(reuc->mode[1] == 0100644);
	177	cl_assert(reuc->mode[2] == 0100644);
	178	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	179	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	180	git_oid_fromstr(&oid, TWO_OUR_OID);
	181	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	182	git_oid_fromstr(&oid, TWO_THEIR_OID);
	183	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	184	}
	185
	186	void test_index_reuc__updates_existing(void)
	187	{
	188	const git_index_reuc_entry *reuc;
	189	git_oid ancestor_oid, our_oid, their_oid, oid;
	190	int index_caps;
	191
	192	git_index_clear(repo_index);
	193
	194	index_caps = git_index_caps(repo_index);
	195
	196	index_caps \|= GIT_INDEXCAP_IGNORE_CASE;
	197	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	198
	199	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	200	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	201	git_oid_fromstr(&their_oid, TWO_THEIR_OID);
	202
	203	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
	204	0100644, &ancestor_oid,
	205	0100644, &our_oid,
	206	0100644, &their_oid));
	207
	208	cl_git_pass(git_index_reuc_add(repo_index, "TWO.txt",
	209	0100644, &our_oid,
	210	0100644, &their_oid,
	211	0100644, &ancestor_oid));
	212
	213	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
	214
	215	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	216
a7f8065f	217	cl_assert_equal_s("TWO.txt", reuc->path);
f45ec1a0 ET	218	git_oid_fromstr(&oid, TWO_OUR_OID);
	219	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	220	git_oid_fromstr(&oid, TWO_THEIR_OID);
	221	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	222	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	223	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	224	}
	225
	226	void test_index_reuc__remove(void)
	227	{
	228	git_oid oid;
	229	const git_index_reuc_entry *reuc;
	230
	231	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	232
	233	cl_git_pass(git_index_reuc_remove(repo_index, 0));
	234	cl_git_fail(git_index_reuc_remove(repo_index, 1));
1fed6b07	235
f45ec1a0 ET	236	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
	237
	238	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	239
a7f8065f	240	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	241	cl_assert(reuc->mode[0] == 0100644);
	242	cl_assert(reuc->mode[1] == 0100644);
	243	cl_assert(reuc->mode[2] == 0100644);
	244	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	245	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	246	git_oid_fromstr(&oid, TWO_OUR_OID);
	247	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	248	git_oid_fromstr(&oid, TWO_THEIR_OID);
	249	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	250	}
	251
	252	void test_index_reuc__write(void)
	253	{
	254	git_oid ancestor_oid, our_oid, their_oid;
	255	const git_index_reuc_entry *reuc;
	256
	257	git_index_clear(repo_index);
	258
	259	/* Write out of order to ensure sorting is correct */
	260	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	261	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	262	git_oid_fromstr(&their_oid, TWO_THEIR_OID);
	263
	264	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
	265	0100644, &ancestor_oid,
	266	0100644, &our_oid,
	267	0100644, &their_oid));
	268
	269	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	270	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	271	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	272
	273	cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
	274	0100644, &ancestor_oid,
	275	0100644, &our_oid,
	276	0100644, &their_oid));
	277
	278	cl_git_pass(git_index_write(repo_index));
f45ec1a0 ET	279	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	280
	281	/* ensure sort order was round-tripped correct */
	282	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
a7f8065f	283	cl_assert_equal_s("one.txt", reuc->path);
1fed6b07	284
f45ec1a0	285	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
a7f8065f	286	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	287	}
f45ec1a0 ET	288
5bddabcc ET	289	static int reuc_entry_exists(void)
	290	{
	291	return (git_index_reuc_get_bypath(repo_index, "newfile.txt") != NULL);
	292	}
	293
	294	void test_index_reuc__cleaned_on_reset_hard(void)
	295	{
	296	git_object *target;
1fed6b07	297
0d847a31	298	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
1fed6b07	299
5bddabcc	300	test_index_reuc__add();
586be3b8	301	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
5bddabcc	302	cl_assert(reuc_entry_exists() == false);
1fed6b07	303
5bddabcc ET	304	git_object_free(target);
	305	}
	306
	307	void test_index_reuc__cleaned_on_reset_mixed(void)
	308	{
	309	git_object *target;
1fed6b07	310
0d847a31	311	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
5bddabcc	312
1fed6b07	313	test_index_reuc__add();
586be3b8	314	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
5bddabcc	315	cl_assert(reuc_entry_exists() == false);
1fed6b07	316
5bddabcc ET	317	git_object_free(target);
	318	}
	319
	320	void test_index_reuc__retained_on_reset_soft(void)
	321	{
	322	git_object *target;
1fed6b07	323
0d847a31	324	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
1fed6b07	325
586be3b8	326	git_reset(repo, target, GIT_RESET_HARD, NULL, NULL);
5bddabcc ET	327
5bddabcc ET	328	test_index_reuc__add();
586be3b8	329	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
5bddabcc	330	cl_assert(reuc_entry_exists() == true);
1fed6b07	331
5bddabcc ET	332	git_object_free(target);
	333	}
	334
	335	void test_index_reuc__cleaned_on_checkout_tree(void)
	336	{
	337	git_oid oid;
	338	git_object *obj;
6affd71f	339	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
1fed6b07	340
5bddabcc ET	341	opts.checkout_strategy = GIT_CHECKOUT_SAFE \| GIT_CHECKOUT_UPDATE_ONLY;
	342
	343	test_index_reuc__add();
	344	git_reference_name_to_id(&oid, repo, "refs/heads/master");
	345	git_object_lookup(&obj, repo, &oid, GIT_OBJ_ANY);
	346	git_checkout_tree(repo, obj, &opts);
	347	cl_assert(reuc_entry_exists() == false);
1fed6b07	348
5bddabcc ET	349	git_object_free(obj);
	350	}
	351
	352	void test_index_reuc__cleaned_on_checkout_head(void)
	353	{
6affd71f	354	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
1fed6b07	355
5bddabcc	356	opts.checkout_strategy = GIT_CHECKOUT_SAFE \| GIT_CHECKOUT_UPDATE_ONLY;
1fed6b07	357
5bddabcc ET	358	test_index_reuc__add();
	359	git_checkout_head(repo, &opts);
	360	cl_assert(reuc_entry_exists() == false);
	361	}
	362
	363	void test_index_reuc__retained_on_checkout_index(void)
	364	{
6affd71f	365	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
1fed6b07	366
5bddabcc	367	opts.checkout_strategy = GIT_CHECKOUT_SAFE \| GIT_CHECKOUT_UPDATE_ONLY;
1fed6b07	368
5bddabcc ET	369	test_index_reuc__add();
	370	git_checkout_index(repo, repo_index, &opts);
	371	cl_assert(reuc_entry_exists() == true);
	372	}