conflicts.c 14.4 KB
Newer Older
Edward Thomson committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
#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 CONFLICTS_ONE_ANCESTOR_OID "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81"
#define CONFLICTS_ONE_OUR_OID "6aea5f295304c36144ad6e9247a291b7f8112399"
#define CONFLICTS_ONE_THEIR_OID "516bd85f78061e09ccc714561d7b504672cb52da"

#define CONFLICTS_TWO_ANCESTOR_OID "84af62840be1b1c47b778a8a249f3ff45155038c"
#define CONFLICTS_TWO_OUR_OID "8b3f43d2402825c200f835ca1762413e386fd0b2"
#define CONFLICTS_TWO_THEIR_OID "220bd62631c8cf7a83ef39c6b94595f00517211e"

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

void test_index_conflicts__cleanup(void)
{
	git_index_free(repo_index);
29 30
	repo_index = NULL;

Edward Thomson committed
31 32 33 34 35 36 37 38 39 40 41 42 43 44
	cl_git_sandbox_cleanup();
}

void test_index_conflicts__add(void)
{
	git_index_entry ancestor_entry, our_entry, their_entry;

	cl_assert(git_index_entrycount(repo_index) == 8);

	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));

	ancestor_entry.path = "test-one.txt";
45
	ancestor_entry.mode = 0100644;
46
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, 1);
47
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID);
Edward Thomson committed
48 49

	our_entry.path = "test-one.txt";
50
	our_entry.mode = 0100644;
51
	GIT_IDXENTRY_STAGE_SET(&our_entry, 2);
52
	git_oid_fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID);
Edward Thomson committed
53 54

	their_entry.path = "test-one.txt";
55
	their_entry.mode = 0100644;
56
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, 2);
57
	git_oid_fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID);
Edward Thomson committed
58 59 60 61 62 63 64 65 66

	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));

	cl_assert(git_index_entrycount(repo_index) == 11);
}

void test_index_conflicts__add_fixes_incorrect_stage(void)
{
	git_index_entry ancestor_entry, our_entry, their_entry;
67
	const git_index_entry *conflict_entry[3];
Edward Thomson committed
68 69 70 71 72 73 74 75

	cl_assert(git_index_entrycount(repo_index) == 8);

	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));

	ancestor_entry.path = "test-one.txt";
76
	ancestor_entry.mode = 0100644;
77
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, 3);
78
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID);
Edward Thomson committed
79 80

	our_entry.path = "test-one.txt";
81
	our_entry.mode = 0100644;
82
	GIT_IDXENTRY_STAGE_SET(&our_entry, 1);
83
	git_oid_fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID);
Edward Thomson committed
84 85

	their_entry.path = "test-one.txt";
86
	their_entry.mode = 0100644;
87
	GIT_IDXENTRY_STAGE_SET(&their_entry, 2);
88
	git_oid_fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID);
Edward Thomson committed
89 90 91 92 93 94 95 96 97 98 99 100

	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));

	cl_assert(git_index_entrycount(repo_index) == 11);

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], repo_index, "test-one.txt"));

	cl_assert(git_index_entry_stage(conflict_entry[0]) == 1);
	cl_assert(git_index_entry_stage(conflict_entry[1]) == 2);
	cl_assert(git_index_entry_stage(conflict_entry[2]) == 3);
}

101 102
void test_index_conflicts__add_removes_stage_zero(void)
{
103
	git_index_entry ancestor_entry, our_entry, their_entry;
104 105 106 107 108 109 110 111
	const git_index_entry *conflict_entry[3];

	cl_assert(git_index_entrycount(repo_index) == 8);

	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));

112 113
	cl_git_mkfile("./mergedrepo/test-one.txt", "new-file\n");
	cl_git_pass(git_index_add_bypath(repo_index, "test-one.txt"));
114 115 116 117
	cl_assert(git_index_entrycount(repo_index) == 9);

	ancestor_entry.path = "test-one.txt";
	ancestor_entry.mode = 0100644;
118
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, 3);
119
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID);
120 121 122

	our_entry.path = "test-one.txt";
	our_entry.mode = 0100644;
123
	GIT_IDXENTRY_STAGE_SET(&our_entry, 1);
124
	git_oid_fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID);
125 126 127

	their_entry.path = "test-one.txt";
	their_entry.mode = 0100644;
128
	GIT_IDXENTRY_STAGE_SET(&their_entry, 2);
129
	git_oid_fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID);
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));

	cl_assert(git_index_entrycount(repo_index) == 11);

	cl_assert_equal_p(NULL, git_index_get_bypath(repo_index, "test-one.txt", 0));

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], repo_index, "test-one.txt"));

	cl_assert_equal_oid(&ancestor_entry.id, &conflict_entry[0]->id);
	cl_assert_equal_i(1, git_index_entry_stage(conflict_entry[0]));
	cl_assert_equal_oid(&our_entry.id, &conflict_entry[1]->id);
	cl_assert_equal_i(2, git_index_entry_stage(conflict_entry[1]));
	cl_assert_equal_oid(&their_entry.id, &conflict_entry[2]->id);
	cl_assert_equal_i(3, git_index_entry_stage(conflict_entry[2]));
}

Edward Thomson committed
147 148
void test_index_conflicts__get(void)
{
149
	const git_index_entry *conflict_entry[3];
Edward Thomson committed
150 151 152 153 154
	git_oid oid;

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
		&conflict_entry[2], repo_index, "conflicts-one.txt"));

155
	cl_assert_equal_s("conflicts-one.txt", conflict_entry[0]->path);
Edward Thomson committed
156 157

	git_oid_fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID);
158
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
Edward Thomson committed
159 160

	git_oid_fromstr(&oid, CONFLICTS_ONE_OUR_OID);
161
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
Edward Thomson committed
162 163

	git_oid_fromstr(&oid, CONFLICTS_ONE_THEIR_OID);
164
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
Edward Thomson committed
165 166 167 168

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
		&conflict_entry[2], repo_index, "conflicts-two.txt"));

169
	cl_assert_equal_s("conflicts-two.txt", conflict_entry[0]->path);
Edward Thomson committed
170 171

	git_oid_fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID);
172
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
Edward Thomson committed
173 174

	git_oid_fromstr(&oid, CONFLICTS_TWO_OUR_OID);
175
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
Edward Thomson committed
176 177

	git_oid_fromstr(&oid, CONFLICTS_TWO_THEIR_OID);
178
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
Edward Thomson committed
179 180
}

181 182 183 184 185 186 187 188 189 190 191
void test_index_conflicts__iterate(void)
{
	git_index_conflict_iterator *iterator;
	const git_index_entry *conflict_entry[3];
	git_oid oid;

	cl_git_pass(git_index_conflict_iterator_new(&iterator, repo_index));

	cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));

	git_oid_fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID);
192
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
193 194 195
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);

	git_oid_fromstr(&oid, CONFLICTS_ONE_OUR_OID);
196
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
197 198 199
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);

	git_oid_fromstr(&oid, CONFLICTS_ONE_THEIR_OID);
200
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
201 202 203 204 205
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);

	cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));

	git_oid_fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID);
206
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
207 208 209
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);

	git_oid_fromstr(&oid, CONFLICTS_TWO_OUR_OID);
210
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
211 212 213
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);

	git_oid_fromstr(&oid, CONFLICTS_TWO_THEIR_OID);
214
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
215 216 217 218 219 220 221 222 223 224 225
	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);

	cl_assert(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator) == GIT_ITEROVER);

	cl_assert(conflict_entry[0] == NULL);
	cl_assert(conflict_entry[2] == NULL);
	cl_assert(conflict_entry[2] == NULL);

	git_index_conflict_iterator_free(iterator);
}

Edward Thomson committed
226 227
void test_index_conflicts__remove(void)
{
Ben Straub committed
228
	const git_index_entry *entry;
Edward Thomson committed
229
	size_t i;
230

Edward Thomson committed
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
	cl_assert(git_index_entrycount(repo_index) == 8);

	cl_git_pass(git_index_conflict_remove(repo_index, "conflicts-one.txt"));
	cl_assert(git_index_entrycount(repo_index) == 5);

	for (i = 0; i < git_index_entrycount(repo_index); i++) {
		cl_assert(entry = git_index_get_byindex(repo_index, i));
		cl_assert(strcmp(entry->path, "conflicts-one.txt") != 0);
	}

	cl_git_pass(git_index_conflict_remove(repo_index, "conflicts-two.txt"));
	cl_assert(git_index_entrycount(repo_index) == 2);

	for (i = 0; i < git_index_entrycount(repo_index); i++) {
		cl_assert(entry = git_index_get_byindex(repo_index, i));
		cl_assert(strcmp(entry->path, "conflicts-two.txt") != 0);
	}
}

250
void test_index_conflicts__moved_to_reuc_on_add(void)
Edward Thomson committed
251
{
Ben Straub committed
252
	const git_index_entry *entry;
Edward Thomson committed
253 254 255 256 257 258
	size_t i;

	cl_assert(git_index_entrycount(repo_index) == 8);

	cl_git_mkfile("./mergedrepo/conflicts-one.txt", "new-file\n");

259
	cl_git_pass(git_index_add_bypath(repo_index, "conflicts-one.txt"));
Edward Thomson committed
260 261 262 263 264 265 266

	cl_assert(git_index_entrycount(repo_index) == 6);

	for (i = 0; i < git_index_entrycount(repo_index); i++) {
		cl_assert(entry = git_index_get_byindex(repo_index, i));

		if (strcmp(entry->path, "conflicts-one.txt") == 0)
267
			cl_assert(!git_index_entry_is_conflict(entry));
Edward Thomson committed
268 269 270
	}
}

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
void test_index_conflicts__moved_to_reuc_on_remove(void)
{
	const git_index_entry *entry;
	size_t i;

	cl_assert(git_index_entrycount(repo_index) == 8);

	cl_git_pass(p_unlink("./mergedrepo/conflicts-one.txt"));

	cl_git_pass(git_index_remove_bypath(repo_index, "conflicts-one.txt"));

	cl_assert(git_index_entrycount(repo_index) == 5);

	for (i = 0; i < git_index_entrycount(repo_index); i++) {
		cl_assert(entry = git_index_get_byindex(repo_index, i));
		cl_assert(strcmp(entry->path, "conflicts-one.txt") != 0);
	}
}

Edward Thomson committed
290 291 292
void test_index_conflicts__remove_all_conflicts(void)
{
	size_t i;
Ben Straub committed
293
	const git_index_entry *entry;
Edward Thomson committed
294 295 296

	cl_assert(git_index_entrycount(repo_index) == 8);

297 298
	cl_assert_equal_i(true, git_index_has_conflicts(repo_index));

Edward Thomson committed
299 300
	git_index_conflict_cleanup(repo_index);

301 302
	cl_assert_equal_i(false, git_index_has_conflicts(repo_index));

Edward Thomson committed
303 304 305 306
	cl_assert(git_index_entrycount(repo_index) == 2);

	for (i = 0; i < git_index_entrycount(repo_index); i++) {
		cl_assert(entry = git_index_get_byindex(repo_index, i));
307
		cl_assert(!git_index_entry_is_conflict(entry));
Edward Thomson committed
308 309 310 311 312 313
	}
}

void test_index_conflicts__partial(void)
{
	git_index_entry ancestor_entry, our_entry, their_entry;
314
	const git_index_entry *conflict_entry[3];
Edward Thomson committed
315 316 317 318 319 320 321 322

	cl_assert(git_index_entrycount(repo_index) == 8);

	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));

	ancestor_entry.path = "test-one.txt";
323
	ancestor_entry.mode = 0100644;
324
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, 1);
325
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID);
Edward Thomson committed
326 327 328 329 330 331 332

	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, NULL, NULL));
	cl_assert(git_index_entrycount(repo_index) == 9);

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
		&conflict_entry[2], repo_index, "test-one.txt"));

333
	cl_assert_equal_oid(&ancestor_entry.id, &conflict_entry[0]->id);
Edward Thomson committed
334 335 336
	cl_assert(conflict_entry[1] == NULL);
	cl_assert(conflict_entry[2] == NULL);
}
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

void test_index_conflicts__case_matters(void)
{
	const git_index_entry *conflict_entry[3];
	git_oid oid;
	const char *upper_case = "DIFFERS-IN-CASE.TXT";
	const char *mixed_case = "Differs-In-Case.txt";
	const char *correct_case;
	bool ignorecase = cl_repo_get_bool(repo, "core.ignorecase");

	git_index_entry ancestor_entry, our_entry, their_entry;

	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));

	ancestor_entry.path = upper_case;
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID);
	ancestor_entry.mode = GIT_FILEMODE_BLOB;

	our_entry.path = upper_case;
	GIT_IDXENTRY_STAGE_SET(&our_entry, GIT_INDEX_STAGE_OURS);
	git_oid_fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID);
	our_entry.mode = GIT_FILEMODE_BLOB;

	their_entry.path = upper_case;
	GIT_IDXENTRY_STAGE_SET(&their_entry, GIT_INDEX_STAGE_THEIRS);
	git_oid_fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID);
	their_entry.mode = GIT_FILEMODE_BLOB;

	cl_git_pass(git_index_conflict_add(repo_index,
		&ancestor_entry, &our_entry, &their_entry));

	ancestor_entry.path = mixed_case;
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
	git_oid_fromstr(&ancestor_entry.id, CONFLICTS_TWO_ANCESTOR_OID);
	ancestor_entry.mode = GIT_FILEMODE_BLOB;

	our_entry.path = mixed_case;
	GIT_IDXENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
	git_oid_fromstr(&our_entry.id, CONFLICTS_TWO_OUR_OID);
	ancestor_entry.mode = GIT_FILEMODE_BLOB;

	their_entry.path = mixed_case;
	GIT_IDXENTRY_STAGE_SET(&their_entry, GIT_INDEX_STAGE_THEIRS);
	git_oid_fromstr(&their_entry.id, CONFLICTS_TWO_THEIR_OID);
	their_entry.mode = GIT_FILEMODE_BLOB;

	cl_git_pass(git_index_conflict_add(repo_index,
		&ancestor_entry, &our_entry, &their_entry));

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
		&conflict_entry[2], repo_index, upper_case));

	/*
	 * We inserted with mixed case last, so on a case-insensitive
	 * fs we should get the mixed case.
	 */
	if (ignorecase)
		correct_case = mixed_case;
	else
		correct_case = upper_case;

	cl_assert_equal_s(correct_case, conflict_entry[0]->path);
	git_oid_fromstr(&oid, ignorecase ? CONFLICTS_TWO_ANCESTOR_OID : CONFLICTS_ONE_ANCESTOR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);

	cl_assert_equal_s(correct_case, conflict_entry[1]->path);
	git_oid_fromstr(&oid, ignorecase ? CONFLICTS_TWO_OUR_OID : CONFLICTS_ONE_OUR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);

	cl_assert_equal_s(correct_case, conflict_entry[2]->path);
	git_oid_fromstr(&oid, ignorecase ? CONFLICTS_TWO_THEIR_OID : CONFLICTS_ONE_THEIR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);

	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
		&conflict_entry[2], repo_index, mixed_case));

	cl_assert_equal_s(mixed_case, conflict_entry[0]->path);
	git_oid_fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[0]->id);

	cl_assert_equal_s(mixed_case, conflict_entry[1]->path);
	git_oid_fromstr(&oid, CONFLICTS_TWO_OUR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[1]->id);

	cl_assert_equal_s(mixed_case, conflict_entry[2]->path);
	git_oid_fromstr(&oid, CONFLICTS_TWO_THEIR_OID);
	cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
}