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

#include "clar_libgit2.h"
#include "index.h"
#include "git2/repository.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_git_pass(git_index_read(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);
}
Commit	Line	Data
f45ec1a0 ET	1	#include "clar_libgit2.h"
	2	#include "index.h"
	3	#include "git2/repository.h"
	4
	5	static git_repository *repo;
	6	static git_index *repo_index;
	7
	8	#define TEST_REPO_PATH "mergedrepo"
	9	#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
	10
	11	#define ONE_ANCESTOR_OID "478871385b9cd03908c5383acfd568bef023c6b3"
	12	#define ONE_OUR_OID "4458b8bc9e72b6c8755ae456f60e9844d0538d8c"
	13	#define ONE_THEIR_OID "8b72416545c7e761b64cecad4f1686eae4078aa8"
	14
	15	#define TWO_ANCESTOR_OID "9d81f82fccc7dcd7de7a1ffead1815294c2e092c"
	16	#define TWO_OUR_OID "8f3c06cff9a83757cec40c80bc9bf31a2582bde9"
	17	#define TWO_THEIR_OID "887b153b165d32409c70163e0f734c090f12f673"
	18
	19	// Fixture setup and teardown
	20	void test_index_reuc__initialize(void)
	21	{
	22	repo = cl_git_sandbox_init("mergedrepo");
	23	git_repository_index(&repo_index, repo);
	24	}
	25
	26	void test_index_reuc__cleanup(void)
	27	{
	28	git_index_free(repo_index);
9094d30b SC	29	repo_index = NULL;
9094d30b SC	30
f45ec1a0 ET	31	cl_git_sandbox_cleanup();
	32	}
	33
eb3c247a ET	34	void test_index_reuc__add(void)
	35	{
	36	git_oid ancestor_oid, our_oid, their_oid;
	37	const git_index_reuc_entry *reuc;
	38
	39	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	40	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	41	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	42
	43	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
	44	0100644, &ancestor_oid,
	45	0100644, &our_oid,
	46	0100644, &their_oid));
	47
	48	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
	49
a7f8065f	50	cl_assert_equal_s("newfile.txt", reuc->path);
eb3c247a ET	51	cl_assert(reuc->mode[0] == 0100644);
	52	cl_assert(reuc->mode[1] == 0100644);
	53	cl_assert(reuc->mode[2] == 0100644);
	54	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	55	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	56	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
	57	}
	58
	59	void test_index_reuc__add_no_ancestor(void)
	60	{
	61	git_oid ancestor_oid, our_oid, their_oid;
	62	const git_index_reuc_entry *reuc;
	63
	64	memset(&ancestor_oid, 0x0, sizeof(git_oid));
	65	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	66	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	67
	68	cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
	69	0, NULL,
	70	0100644, &our_oid,
	71	0100644, &their_oid));
	72
	73	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
	74
a7f8065f	75	cl_assert_equal_s("newfile.txt", reuc->path);
eb3c247a ET	76	cl_assert(reuc->mode[0] == 0);
	77	cl_assert(reuc->mode[1] == 0100644);
	78	cl_assert(reuc->mode[2] == 0100644);
	79	cl_assert(git_oid_cmp(&reuc->oid[0], &ancestor_oid) == 0);
	80	cl_assert(git_oid_cmp(&reuc->oid[1], &our_oid) == 0);
	81	cl_assert(git_oid_cmp(&reuc->oid[2], &their_oid) == 0);
	82	}
	83
f45ec1a0 ET	84	void test_index_reuc__read_bypath(void)
	85	{
	86	const git_index_reuc_entry *reuc;
	87	git_oid oid;
	88
	89	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	90
	91	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "two.txt"));
	92
a7f8065f	93	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	94	cl_assert(reuc->mode[0] == 0100644);
	95	cl_assert(reuc->mode[1] == 0100644);
	96	cl_assert(reuc->mode[2] == 0100644);
	97	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	98	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	99	git_oid_fromstr(&oid, TWO_OUR_OID);
	100	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	101	git_oid_fromstr(&oid, TWO_THEIR_OID);
	102	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	103
	104	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "one.txt"));
	105
a7f8065f	106	cl_assert_equal_s("one.txt", reuc->path);
f45ec1a0 ET	107	cl_assert(reuc->mode[0] == 0100644);
	108	cl_assert(reuc->mode[1] == 0100644);
	109	cl_assert(reuc->mode[2] == 0100644);
	110	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	111	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	112	git_oid_fromstr(&oid, ONE_OUR_OID);
	113	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	114	git_oid_fromstr(&oid, ONE_THEIR_OID);
	115	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	116	}
	117
	118	void test_index_reuc__ignore_case(void)
	119	{
	120	const git_index_reuc_entry *reuc;
	121	git_oid oid;
	122	int index_caps;
	123
	124	index_caps = git_index_caps(repo_index);
	125
	126	index_caps &= ~GIT_INDEXCAP_IGNORE_CASE;
	127	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	128
	129	cl_assert(!git_index_reuc_get_bypath(repo_index, "TWO.txt"));
	130
	131	index_caps \|= GIT_INDEXCAP_IGNORE_CASE;
	132	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	133
	134	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	135
	136	cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "TWO.txt"));
	137
a7f8065f	138	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	139	cl_assert(reuc->mode[0] == 0100644);
	140	cl_assert(reuc->mode[1] == 0100644);
	141	cl_assert(reuc->mode[2] == 0100644);
	142	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	143	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	144	git_oid_fromstr(&oid, TWO_OUR_OID);
	145	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	146	git_oid_fromstr(&oid, TWO_THEIR_OID);
	147	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	148	}
	149
	150	void test_index_reuc__read_byindex(void)
	151	{
	152	const git_index_reuc_entry *reuc;
	153	git_oid oid;
	154
	155	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	156
	157	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	158
a7f8065f	159	cl_assert_equal_s("one.txt", reuc->path);
f45ec1a0 ET	160	cl_assert(reuc->mode[0] == 0100644);
	161	cl_assert(reuc->mode[1] == 0100644);
	162	cl_assert(reuc->mode[2] == 0100644);
	163	git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
	164	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	165	git_oid_fromstr(&oid, ONE_OUR_OID);
	166	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	167	git_oid_fromstr(&oid, ONE_THEIR_OID);
	168	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	169
	170	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
	171
a7f8065f	172	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	173	cl_assert(reuc->mode[0] == 0100644);
	174	cl_assert(reuc->mode[1] == 0100644);
	175	cl_assert(reuc->mode[2] == 0100644);
	176	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	177	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	178	git_oid_fromstr(&oid, TWO_OUR_OID);
	179	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	180	git_oid_fromstr(&oid, TWO_THEIR_OID);
	181	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	182	}
	183
	184	void test_index_reuc__updates_existing(void)
	185	{
	186	const git_index_reuc_entry *reuc;
	187	git_oid ancestor_oid, our_oid, their_oid, oid;
	188	int index_caps;
	189
	190	git_index_clear(repo_index);
	191
	192	index_caps = git_index_caps(repo_index);
	193
	194	index_caps \|= GIT_INDEXCAP_IGNORE_CASE;
	195	cl_git_pass(git_index_set_caps(repo_index, index_caps));
	196
	197	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	198	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	199	git_oid_fromstr(&their_oid, TWO_THEIR_OID);
	200
	201	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
	202	0100644, &ancestor_oid,
	203	0100644, &our_oid,
	204	0100644, &their_oid));
	205
	206	cl_git_pass(git_index_reuc_add(repo_index, "TWO.txt",
	207	0100644, &our_oid,
	208	0100644, &their_oid,
	209	0100644, &ancestor_oid));
	210
	211	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
	212
	213	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	214
a7f8065f	215	cl_assert_equal_s("TWO.txt", reuc->path);
f45ec1a0 ET	216	git_oid_fromstr(&oid, TWO_OUR_OID);
	217	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	218	git_oid_fromstr(&oid, TWO_THEIR_OID);
	219	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	220	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	221	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	222	}
	223
	224	void test_index_reuc__remove(void)
	225	{
	226	git_oid oid;
	227	const git_index_reuc_entry *reuc;
	228
	229	cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
	230
	231	cl_git_pass(git_index_reuc_remove(repo_index, 0));
	232	cl_git_fail(git_index_reuc_remove(repo_index, 1));
	233
	234	cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
	235
	236	cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
	237
a7f8065f	238	cl_assert_equal_s("two.txt", reuc->path);
f45ec1a0 ET	239	cl_assert(reuc->mode[0] == 0100644);
	240	cl_assert(reuc->mode[1] == 0100644);
	241	cl_assert(reuc->mode[2] == 0100644);
	242	git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
	243	cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
	244	git_oid_fromstr(&oid, TWO_OUR_OID);
	245	cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
	246	git_oid_fromstr(&oid, TWO_THEIR_OID);
	247	cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
	248	}
	249
	250	void test_index_reuc__write(void)
	251	{
	252	git_oid ancestor_oid, our_oid, their_oid;
	253	const git_index_reuc_entry *reuc;
	254
	255	git_index_clear(repo_index);
	256
	257	/* Write out of order to ensure sorting is correct */
	258	git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
	259	git_oid_fromstr(&our_oid, TWO_OUR_OID);
	260	git_oid_fromstr(&their_oid, TWO_THEIR_OID);
	261
	262	cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
	263	0100644, &ancestor_oid,
	264	0100644, &our_oid,
	265	0100644, &their_oid));
	266
	267	git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
	268	git_oid_fromstr(&our_oid, ONE_OUR_OID);
	269	git_oid_fromstr(&their_oid, ONE_THEIR_OID);
	270
	271	cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
	272	0100644, &ancestor_oid,
	273	0100644, &our_oid,
	274	0100644, &their_oid));
	275
	276	cl_git_pass(git_index_write(repo_index));
	277
	278	cl_git_pass(git_index_read(repo_index));
	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);
f45ec1a0 ET	284
f45ec1a0 ET	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