workdir.c 38.3 KB
Newer Older
1 2
#include "clar_libgit2.h"
#include "diff_helpers.h"
3
#include "repository.h"
4 5 6 7 8 9 10 11 12

static git_repository *g_repo = NULL;

void test_diff_workdir__initialize(void)
{
}

void test_diff_workdir__cleanup(void)
{
13
	cl_git_sandbox_cleanup();
14 15 16 17
}

void test_diff_workdir__to_index(void)
{
18
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
19 20
	git_diff_list *diff = NULL;
	diff_expects exp;
Russell Belfer committed
21
	int use_iterator;
22

23 24
	g_repo = cl_git_sandbox_init("status");

25 26 27 28
	opts.context_lines = 3;
	opts.interhunk_lines = 1;
	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

29
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
30

Russell Belfer committed
31 32 33 34 35
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
36
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
37 38
		else
			cl_git_pass(git_diff_foreach(
39
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
40 41 42 43 44 45 46 47 48

		/* to generate these values:
		 * - cd to tests/resources/status,
		 * - mv .gitted .git
		 * - git diff --name-status
		 * - git diff
		 * - mv .git .gitted
		 */
		cl_assert_equal_i(13, exp.files);
49 50 51 52 53
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
54 55 56 57 58 59 60 61

		cl_assert_equal_i(8, exp.hunks);

		cl_assert_equal_i(14, exp.lines);
		cl_assert_equal_i(5, exp.line_ctxt);
		cl_assert_equal_i(4, exp.line_adds);
		cl_assert_equal_i(5, exp.line_dels);
	}
62 63 64 65 66 67 68 69 70

	git_diff_list_free(diff);
}

void test_diff_workdir__to_tree(void)
{
	/* grabbed a couple of commit oids from the history of the attr repo */
	const char *a_commit = "26a125ee1bf"; /* the current HEAD */
	const char *b_commit = "0017bd4ab1ec3"; /* the start */
71
	git_tree *a, *b;
72
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
73 74 75
	git_diff_list *diff = NULL;
	git_diff_list *diff2 = NULL;
	diff_expects exp;
Russell Belfer committed
76
	int use_iterator;
77

78 79 80 81 82
	g_repo = cl_git_sandbox_init("status");

	a = resolve_commit_oid_to_tree(g_repo, a_commit);
	b = resolve_commit_oid_to_tree(g_repo, b_commit);

83 84 85 86
	opts.context_lines = 3;
	opts.interhunk_lines = 1;
	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

87
	/* You can't really generate the equivalent of git_diff_tree_to_workdir()
88 89 90 91 92 93 94 95 96
	 * using C git.  It really wants to interpose the index into the diff.
	 *
	 * To validate the following results with command line git, I ran the
	 * following:
	 * - git ls-tree 26a125
	 * - find . ! -path ./.git/\* -a -type f | git hash-object --stdin-paths
	 * The results are documented at the bottom of this file in the
	 * long comment entitled "PREPARATION OF TEST DATA".
	 */
97
	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
98

Russell Belfer committed
99 100
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));
101

Russell Belfer committed
102 103
		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
104
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
105 106
		else
			cl_git_pass(git_diff_foreach(
107
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
108 109

		cl_assert_equal_i(14, exp.files);
110 111 112 113 114
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
115
	}
116 117 118 119 120 121 122 123 124 125 126 127 128 129

	/* Since there is no git diff equivalent, let's just assume that the
	 * text diffs produced by git_diff_foreach are accurate here.  We will
	 * do more apples-to-apples test comparison below.
	 */

	git_diff_list_free(diff);
	diff = NULL;
	memset(&exp, 0, sizeof(exp));

	/* This is a compatible emulation of "git diff <sha>" which looks like
	 * a workdir to tree diff (even though it is not really).  This is what
	 * you would get from "git diff --name-status 26a125ee1bf"
	 */
130 131
	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));
132 133 134
	cl_git_pass(git_diff_merge(diff, diff2));
	git_diff_list_free(diff2);

Russell Belfer committed
135 136 137 138 139
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
140
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
141 142
		else
			cl_git_pass(git_diff_foreach(
143
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
144

Russell Belfer committed
145
		cl_assert_equal_i(15, exp.files);
146 147 148 149 150
		cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNTRACKED]);
151

Russell Belfer committed
152
		cl_assert_equal_i(11, exp.hunks);
153

Russell Belfer committed
154 155 156 157 158
		cl_assert_equal_i(17, exp.lines);
		cl_assert_equal_i(4, exp.line_ctxt);
		cl_assert_equal_i(8, exp.line_adds);
		cl_assert_equal_i(5, exp.line_dels);
	}
159 160 161 162 163 164 165 166

	git_diff_list_free(diff);
	diff = NULL;
	memset(&exp, 0, sizeof(exp));

	/* Again, emulating "git diff <sha>" for testing purposes using
	 * "git diff --name-status 0017bd4ab1ec3" instead.
	 */
167 168
	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));
169 170 171
	cl_git_pass(git_diff_merge(diff, diff2));
	git_diff_list_free(diff2);

Russell Belfer committed
172 173
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));
174

Russell Belfer committed
175 176
		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
177
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
178 179
		else
			cl_git_pass(git_diff_foreach(
180
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
181

Russell Belfer committed
182
		cl_assert_equal_i(16, exp.files);
183 184 185 186 187
		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNTRACKED]);
188

Russell Belfer committed
189 190 191 192 193 194 195
		cl_assert_equal_i(12, exp.hunks);

		cl_assert_equal_i(19, exp.lines);
		cl_assert_equal_i(3, exp.line_ctxt);
		cl_assert_equal_i(12, exp.line_adds);
		cl_assert_equal_i(4, exp.line_dels);
	}
196

197 198
	git_diff_list_free(diff);

199 200 201 202
	git_tree_free(a);
	git_tree_free(b);
}

203 204
void test_diff_workdir__to_index_with_pathspec(void)
{
205
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
206 207 208
	git_diff_list *diff = NULL;
	diff_expects exp;
	char *pathspec = NULL;
Russell Belfer committed
209
	int use_iterator;
210

211 212
	g_repo = cl_git_sandbox_init("status");

213 214 215 216 217 218
	opts.context_lines = 3;
	opts.interhunk_lines = 1;
	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
	opts.pathspec.strings = &pathspec;
	opts.pathspec.count   = 1;

219
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
220

Russell Belfer committed
221 222 223 224 225
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
226
				diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
227
		else
228
			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
229 230

		cl_assert_equal_i(13, exp.files);
231 232 233 234 235
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
236
	}
237 238 239 240 241

	git_diff_list_free(diff);

	pathspec = "modified_file";

242
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
243

Russell Belfer committed
244 245 246 247 248
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
249
				diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
250
		else
251
			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
252 253

		cl_assert_equal_i(1, exp.files);
254 255 256 257 258
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
259
	}
260 261 262 263 264

	git_diff_list_free(diff);

	pathspec = "subdir";

265
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
266

Russell Belfer committed
267 268 269 270 271
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
272
				diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
273
		else
274
			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
275 276

		cl_assert_equal_i(3, exp.files);
277 278 279 280 281
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
282
	}
283 284 285 286 287

	git_diff_list_free(diff);

	pathspec = "*_deleted";

288
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
289

Russell Belfer committed
290 291 292 293 294
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
295
				diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
296
		else
297
			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
Russell Belfer committed
298 299

		cl_assert_equal_i(2, exp.files);
300 301 302 303 304
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(2, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);
Russell Belfer committed
305
	}
306 307 308 309

	git_diff_list_free(diff);
}

310 311 312 313
void test_diff_workdir__filemode_changes(void)
{
	git_diff_list *diff = NULL;
	diff_expects exp;
Russell Belfer committed
314
	int use_iterator;
315 316 317 318 319 320

	if (!cl_is_chmod_supported())
		return;

	g_repo = cl_git_sandbox_init("issue_592");

321
	cl_repo_set_bool(g_repo, "core.filemode", true);
322 323 324

	/* test once with no mods */

325
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
326

Russell Belfer committed
327 328
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));
329

Russell Belfer committed
330 331
		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
332
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
333 334
		else
			cl_git_pass(git_diff_foreach(
335
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
336 337

		cl_assert_equal_i(0, exp.files);
338
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
339 340
		cl_assert_equal_i(0, exp.hunks);
	}
341 342 343 344 345 346 347

	git_diff_list_free(diff);

	/* chmod file and test again */

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

348
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
349

Russell Belfer committed
350 351
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));
352

Russell Belfer committed
353 354
		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
355
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
356 357
		else
			cl_git_pass(git_diff_foreach(
358
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
359 360

		cl_assert_equal_i(1, exp.files);
361
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
362 363
		cl_assert_equal_i(0, exp.hunks);
	}
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379

	git_diff_list_free(diff);

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));
}

void test_diff_workdir__filemode_changes_with_filemode_false(void)
{
	git_diff_list *diff = NULL;
	diff_expects exp;

	if (!cl_is_chmod_supported())
		return;

	g_repo = cl_git_sandbox_init("issue_592");

380
	cl_repo_set_bool(g_repo, "core.filemode", false);
381 382 383

	/* test once with no mods */

384
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
385 386 387

	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
388
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
389 390

	cl_assert_equal_i(0, exp.files);
391
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
392 393 394 395 396 397 398 399
	cl_assert_equal_i(0, exp.hunks);

	git_diff_list_free(diff);

	/* chmod file and test again */

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

400
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
401 402 403

	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
404
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
405 406

	cl_assert_equal_i(0, exp.files);
407
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
408 409 410 411 412 413 414
	cl_assert_equal_i(0, exp.hunks);

	git_diff_list_free(diff);

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));
}

415 416
void test_diff_workdir__head_index_and_workdir_all_differ(void)
{
417
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
418 419 420 421
	git_diff_list *diff_i2t = NULL, *diff_w2i = NULL;
	diff_expects exp;
	char *pathspec = "staged_changes_modified_file";
	git_tree *tree;
Russell Belfer committed
422
	int use_iterator;
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438

	/* For this file,
	 * - head->index diff has 1 line of context, 1 line of diff
	 * - index->workdir diff has 2 lines of context, 1 line of diff
	 * but
	 * - head->workdir diff has 1 line of context, 2 lines of diff
	 * Let's make sure the right one is returned from each fn.
	 */

	g_repo = cl_git_sandbox_init("status");

	tree = resolve_commit_oid_to_tree(g_repo, "26a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f");

	opts.pathspec.strings = &pathspec;
	opts.pathspec.count   = 1;

439 440
	cl_git_pass(git_diff_tree_to_index(&diff_i2t, g_repo, tree, NULL, &opts));
	cl_git_pass(git_diff_index_to_workdir(&diff_w2i, g_repo, NULL, &opts));
441

Russell Belfer committed
442 443 444 445 446
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
447
				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
448 449
		else
			cl_git_pass(git_diff_foreach(
450
				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
451 452

		cl_assert_equal_i(1, exp.files);
453 454 455
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
456 457 458 459 460 461 462 463 464 465 466 467
		cl_assert_equal_i(1, exp.hunks);
		cl_assert_equal_i(2, exp.lines);
		cl_assert_equal_i(1, exp.line_ctxt);
		cl_assert_equal_i(1, exp.line_adds);
		cl_assert_equal_i(0, exp.line_dels);
	}

	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
468
				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
469 470
		else
			cl_git_pass(git_diff_foreach(
471
				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
472 473

		cl_assert_equal_i(1, exp.files);
474 475 476
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
477 478 479 480 481 482
		cl_assert_equal_i(1, exp.hunks);
		cl_assert_equal_i(3, exp.lines);
		cl_assert_equal_i(2, exp.line_ctxt);
		cl_assert_equal_i(1, exp.line_adds);
		cl_assert_equal_i(0, exp.line_dels);
	}
483 484 485

	cl_git_pass(git_diff_merge(diff_i2t, diff_w2i));

Russell Belfer committed
486 487 488 489 490
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
491
				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
492 493
		else
			cl_git_pass(git_diff_foreach(
494
				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
495 496

		cl_assert_equal_i(1, exp.files);
497 498 499
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
500 501 502 503 504 505
		cl_assert_equal_i(1, exp.hunks);
		cl_assert_equal_i(3, exp.lines);
		cl_assert_equal_i(1, exp.line_ctxt);
		cl_assert_equal_i(2, exp.line_adds);
		cl_assert_equal_i(0, exp.line_dels);
	}
506 507 508

	git_diff_list_free(diff_i2t);
	git_diff_list_free(diff_w2i);
Carlos Martín Nieto committed
509 510

	git_tree_free(tree);
511 512 513 514
}

void test_diff_workdir__eof_newline_changes(void)
{
515
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
516 517 518
	git_diff_list *diff = NULL;
	diff_expects exp;
	char *pathspec = "current_file";
Russell Belfer committed
519
	int use_iterator;
520 521 522 523 524 525

	g_repo = cl_git_sandbox_init("status");

	opts.pathspec.strings = &pathspec;
	opts.pathspec.count   = 1;

526
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
527

Russell Belfer committed
528 529 530 531 532
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
533
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
534 535
		else
			cl_git_pass(git_diff_foreach(
536
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
537 538

		cl_assert_equal_i(0, exp.files);
539 540 541
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
542 543 544 545 546 547
		cl_assert_equal_i(0, exp.hunks);
		cl_assert_equal_i(0, exp.lines);
		cl_assert_equal_i(0, exp.line_ctxt);
		cl_assert_equal_i(0, exp.line_adds);
		cl_assert_equal_i(0, exp.line_dels);
	}
548 549 550 551 552

	git_diff_list_free(diff);

	cl_git_append2file("status/current_file", "\n");

553
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
554

Russell Belfer committed
555 556 557 558 559
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
560
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
561 562
		else
			cl_git_pass(git_diff_foreach(
563
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
564 565

		cl_assert_equal_i(1, exp.files);
566 567 568
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
569 570 571 572 573 574
		cl_assert_equal_i(1, exp.hunks);
		cl_assert_equal_i(2, exp.lines);
		cl_assert_equal_i(1, exp.line_ctxt);
		cl_assert_equal_i(1, exp.line_adds);
		cl_assert_equal_i(0, exp.line_dels);
	}
575 576 577 578 579

	git_diff_list_free(diff);

	cl_git_rewritefile("status/current_file", "current_file");

580
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
581

Russell Belfer committed
582 583 584 585 586
	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
		memset(&exp, 0, sizeof(exp));

		if (use_iterator)
			cl_git_pass(diff_foreach_via_iterator(
587
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
588 589
		else
			cl_git_pass(git_diff_foreach(
590
				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
Russell Belfer committed
591 592

		cl_assert_equal_i(1, exp.files);
593 594 595
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
Russell Belfer committed
596 597 598 599 600 601
		cl_assert_equal_i(1, exp.hunks);
		cl_assert_equal_i(3, exp.lines);
		cl_assert_equal_i(0, exp.line_ctxt);
		cl_assert_equal_i(1, exp.line_adds);
		cl_assert_equal_i(2, exp.line_dels);
	}
602 603 604 605

	git_diff_list_free(diff);
}

606 607
/* PREPARATION OF TEST DATA
 *
608
 * Since there is no command line equivalent of git_diff_tree_to_workdir,
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
 * it was a bit of a pain to confirm that I was getting the expected
 * results in the first part of this tests.  Here is what I ended up
 * doing to set my expectation for the file counts and results:
 *
 * Running "git ls-tree 26a125" and "git ls-tree aa27a6" shows:
 *
 *  A a0de7e0ac200c489c41c59dfa910154a70264e6e	current_file
 *  B 5452d32f1dd538eb0405e8a83cc185f79e25e80f	file_deleted
 *  C 452e4244b5d083ddf0460acf1ecc74db9dcfa11a	modified_file
 *  D 32504b727382542f9f089e24fddac5e78533e96c	staged_changes
 *  E 061d42a44cacde5726057b67558821d95db96f19	staged_changes_file_deleted
 *  F 70bd9443ada07063e7fbf0b3ff5c13f7494d89c2	staged_changes_modified_file
 *  G e9b9107f290627c04d097733a10055af941f6bca	staged_delete_file_deleted
 *  H dabc8af9bd6e9f5bbe96a176f1a24baf3d1f8916	staged_delete_modified_file
 *  I 53ace0d1cc1145a5f4fe4f78a186a60263190733	subdir/current_file
 *  J 1888c805345ba265b0ee9449b8877b6064592058	subdir/deleted_file
 *  K a6191982709b746d5650e93c2acf34ef74e11504	subdir/modified_file
 *  L e8ee89e15bbe9b20137715232387b3de5b28972e	subdir.txt
 *
 * --------
 *
 * find . ! -path ./.git/\* -a -type f | git hash-object --stdin-paths
 *
 *  A a0de7e0ac200c489c41c59dfa910154a70264e6e current_file
 *  M 6a79f808a9c6bc9531ac726c184bbcd9351ccf11 ignored_file
 *  C 0a539630525aca2e7bc84975958f92f10a64c9b6 modified_file
 *  N d4fa8600b4f37d7516bef4816ae2c64dbf029e3a new_file
 *  D 55d316c9ba708999f1918e9677d01dfcae69c6b9 staged_changes
 *  F 011c3440d5c596e21d836aa6d7b10eb581f68c49 staged_changes_modified_file
 *  H dabc8af9bd6e9f5bbe96a176f1a24baf3d1f8916 staged_delete_modified_file
 *  O 529a16e8e762d4acb7b9636ff540a00831f9155a staged_new_file
 *  P 8b090c06d14ffa09c4e880088ebad33893f921d1 staged_new_file_modified_file
 *  I 53ace0d1cc1145a5f4fe4f78a186a60263190733 subdir/current_file
 *  K 57274b75eeb5f36fd55527806d567b2240a20c57 subdir/modified_file
 *  Q 80a86a6931b91bc01c2dbf5ca55bdd24ad1ef466 subdir/new_file
 *  L e8ee89e15bbe9b20137715232387b3de5b28972e subdir.txt
 *
 * --------
 *
 *  A - current_file (UNMODIFIED) -> not in results
 *  B D file_deleted
 *  M I ignored_file (IGNORED)
 *  C M modified_file
 *  N U new_file (UNTRACKED)
 *  D M staged_changes
 *  E D staged_changes_file_deleted
 *  F M staged_changes_modified_file
 *  G D staged_delete_file_deleted
 *  H - staged_delete_modified_file (UNMODIFIED) -> not in results
 *  O U staged_new_file
 *  P U staged_new_file_modified_file
 *  I - subdir/current_file (UNMODIFIED) -> not in results
 *  J D subdir/deleted_file
 *  K M subdir/modified_file
 *  Q U subdir/new_file
 *  L - subdir.txt (UNMODIFIED) -> not in results
 *
 * Expect 13 files, 0 ADD, 4 DEL, 4 MOD, 1 IGN, 4 UNTR
 */
668 669 670 671 672 673 674


void test_diff_workdir__larger_hunks(void)
{
	const char *a_commit = "d70d245ed97ed2aa596dd1af6536e4bfdb047b69";
	const char *b_commit = "7a9e0b02e63179929fed24f0a3e0f19168114d10";
	git_tree *a, *b;
675
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
676
	size_t i, d, num_d, h, num_h, l, num_l, header_len, line_len;
677 678 679 680 681 682 683 684 685 686 687

	g_repo = cl_git_sandbox_init("diff");

	cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL);
	cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL);

	opts.context_lines = 1;
	opts.interhunk_lines = 0;

	for (i = 0; i <= 2; ++i) {
		git_diff_list *diff = NULL;
688
		git_diff_patch *patch;
689
		const git_diff_range *range;
690 691
		const char *header, *line;
		char origin;
692 693 694 695

		/* okay, this is a bit silly, but oh well */
		switch (i) {
		case 0:
696
			cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
697 698
			break;
		case 1:
699
			cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
700 701
			break;
		case 2:
702
			cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, b, &opts));
703 704 705
			break;
		}

706 707
		num_d = git_diff_num_deltas(diff);
		cl_assert_equal_i(2, (int)num_d);
708

709 710 711
		for (d = 0; d < num_d; ++d) {
			cl_git_pass(git_diff_get_patch(&patch, NULL, diff, d));
			cl_assert(patch);
712

713 714 715 716
			num_h = git_diff_patch_num_hunks(patch);
			for (h = 0; h < num_h; h++) {
				cl_git_pass(git_diff_patch_get_hunk(
					&range, &header, &header_len, &num_l, patch, h));
717

718 719 720 721
				for (l = 0; l < num_l; ++l) {
					cl_git_pass(git_diff_patch_get_line_in_hunk(
						&origin, &line, &line_len, NULL, NULL, patch, h, l));
					cl_assert(line);
722 723
				}

724 725 726
				/* confirm fail after the last item */
				cl_git_fail(git_diff_patch_get_line_in_hunk(
					&origin, &line, &line_len, NULL, NULL, patch, h, num_l));
727 728
			}

729 730 731
			/* confirm fail after the last item */
			cl_git_fail(git_diff_patch_get_hunk(
				&range, &header, &header_len, &num_l, patch, num_h));
732

733 734
			git_diff_patch_free(patch);
		}
735 736 737 738 739 740 741

		git_diff_list_free(diff);
	}

	git_tree_free(a);
	git_tree_free(b);
}
742 743 744

/* Set up a test that exercises this code. The easiest test using existing
 * test data is probably to create a sandbox of submod2 and then run a
745
 * git_diff_tree_to_workdir against tree
746 747 748 749 750 751 752 753 754 755 756 757 758 759
 * 873585b94bdeabccea991ea5e3ec1a277895b698. As for what you should actually
 * test, you can start by just checking that the number of lines of diff
 * content matches the actual output of git diff. That will at least
 * demonstrate that the submodule content is being used to generate somewhat
 * comparable outputs. It is a test that would fail without this code and
 * will succeed with it.
 */

#include "../submodule/submodule_helpers.h"

void test_diff_workdir__submodules(void)
{
	const char *a_commit = "873585b94bdeabccea991ea5e3ec1a277895b698";
	git_tree *a;
760
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
761 762 763 764 765 766 767 768 769
	git_diff_list *diff = NULL;
	diff_expects exp;

	g_repo = cl_git_sandbox_init("submod2");

	cl_fixture_sandbox("submod2_target");
	p_rename("submod2_target/.gitted", "submod2_target/.git");

	rewrite_gitmodules(git_repository_workdir(g_repo));
770 771
	p_rename("submod2/not-submodule/.gitted", "submod2/not-submodule/.git");
	p_rename("submod2/not/.gitted", "submod2/not/.git");
772 773 774 775 776 777 778

	cl_fixture_cleanup("submod2_target");

	a = resolve_commit_oid_to_tree(g_repo, a_commit);

	opts.flags =
		GIT_DIFF_INCLUDE_UNTRACKED |
779
		GIT_DIFF_INCLUDE_IGNORED |
780 781 782
		GIT_DIFF_RECURSE_UNTRACKED_DIRS |
		GIT_DIFF_INCLUDE_UNTRACKED_CONTENT;

783
	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
784 785 786 787 788 789

	/* diff_print(stderr, diff); */

	/* essentially doing: git diff 873585b94bdeabccea991ea5e3ec1a277895b698 */

	memset(&exp, 0, sizeof(exp));
790

791
	cl_git_pass(git_diff_foreach(
792
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
793

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
	/* so "git diff 873585" returns:
	 *  M   .gitmodules
	 *  A   just_a_dir/contents
	 *  A   just_a_file
	 *  A   sm_added_and_uncommited
	 *  A   sm_changed_file
	 *  A   sm_changed_head
	 *  A   sm_changed_index
	 *  A   sm_changed_untracked_file
	 *  M   sm_missing_commits
	 *  A   sm_unchanged
	 * which is a little deceptive because of the difference between the
	 * "git diff <treeish>" results from "git_diff_tree_to_workdir".  The
	 * only significant difference is that those Added items will show up
	 * as Untracked items in the pure libgit2 diff.
	 *
810
	 * Then add in the two extra ignored items "not" and "not-submodule"
811
	 * to get the 12 files reported here.
812 813
	 */

814
	cl_assert_equal_i(12, exp.files);
815

816 817
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
818
	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
819 820
	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(8, exp.file_status[GIT_DELTA_UNTRACKED]);
821 822 823 824 825 826 827 828 829 830 831 832 833

	/* the following numbers match "git diff 873585" exactly */

	cl_assert_equal_i(9, exp.hunks);

	cl_assert_equal_i(33, exp.lines);
	cl_assert_equal_i(2, exp.line_ctxt);
	cl_assert_equal_i(30, exp.line_adds);
	cl_assert_equal_i(1, exp.line_dels);

	git_diff_list_free(diff);
	git_tree_free(a);
}
834 835 836

void test_diff_workdir__cannot_diff_against_a_bare_repository(void)
{
837
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
838 839 840 841 842
	git_diff_list *diff = NULL;
	git_tree *tree;

	g_repo = cl_git_sandbox_init("testrepo.git");

843
	cl_assert_equal_i(
844
		GIT_EBAREREPO, git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
845 846

	cl_git_pass(git_repository_head_tree(&tree, g_repo));
847 848

	cl_assert_equal_i(
849
		GIT_EBAREREPO, git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
850 851 852

	git_tree_free(tree);
}
853 854 855 856 857

void test_diff_workdir__to_null_tree(void)
{
	git_diff_list *diff;
	diff_expects exp;
858
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
859 860 861 862 863 864

	opts.flags = GIT_DIFF_INCLUDE_UNTRACKED |
		GIT_DIFF_RECURSE_UNTRACKED_DIRS;

	g_repo = cl_git_sandbox_init("status");

865
	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
866 867 868 869 870 871 872 873 874 875

	memset(&exp, 0, sizeof(exp));

	cl_git_pass(git_diff_foreach(
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));

	cl_assert_equal_i(exp.files, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);
}
876 877 878 879 880 881 882 883 884 885

void test_diff_workdir__checks_options_version(void)
{
	git_diff_list *diff;
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	const git_error *err;

	g_repo = cl_git_sandbox_init("status");

	opts.version = 0;
886
	cl_git_fail(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
887 888 889 890 891
	err = giterr_last();
	cl_assert_equal_i(GITERR_INVALID, err->klass);

	giterr_clear();
	opts.version = 1024;
892
	cl_git_fail(git_diff_tree_to_workdir(&diff, g_repo, NULL, &opts));
893 894 895
	err = giterr_last();
	cl_assert_equal_i(GITERR_INVALID, err->klass);
}
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937

void test_diff_workdir__can_diff_empty_file(void)
{
	git_diff_list *diff;
	git_tree *tree;
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	struct stat st;
	git_diff_patch *patch;

	g_repo = cl_git_sandbox_init("attr_index");

	tree = resolve_commit_oid_to_tree(g_repo, "3812cfef3661"); /* HEAD */

	/* baseline - make sure there are no outstanding diffs */

	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
	cl_assert_equal_i(2, (int)git_diff_num_deltas(diff));
	git_diff_list_free(diff);

	/* empty contents of file */

	cl_git_rewritefile("attr_index/README.txt", "");
	cl_git_pass(git_path_lstat("attr_index/README.txt", &st));
	cl_assert_equal_i(0, (int)st.st_size);

	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
	cl_assert_equal_i(3, (int)git_diff_num_deltas(diff));
	/* diffs are: .gitattributes, README.txt, sub/sub/.gitattributes */
	cl_git_pass(git_diff_get_patch(&patch, NULL, diff, 1));
	git_diff_patch_free(patch);
	git_diff_list_free(diff);

	/* remove a file altogether */

	cl_git_pass(p_unlink("attr_index/README.txt"));
	cl_assert(!git_path_exists("attr_index/README.txt"));

	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
	cl_assert_equal_i(3, (int)git_diff_num_deltas(diff));
	cl_git_pass(git_diff_get_patch(&patch, NULL, diff, 1));
	git_diff_patch_free(patch);
	git_diff_list_free(diff);
Vicent Marti committed
938 939

	git_tree_free(tree);
940
}
941 942 943 944 945 946 947 948 949

void test_diff_workdir__to_index_issue_1397(void)
{
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	git_diff_list *diff = NULL;
	diff_expects exp;

	g_repo = cl_git_sandbox_init("issue_1397");

Russell Belfer committed
950
	cl_repo_set_bool(g_repo, "core.autocrlf", true);
951 952 953 954 955 956

	opts.context_lines = 3;
	opts.interhunk_lines = 1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

Russell Belfer committed
957 958 959
	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
960

Russell Belfer committed
961 962 963
	cl_assert_equal_i(0, exp.files);
	cl_assert_equal_i(0, exp.hunks);
	cl_assert_equal_i(0, exp.lines);
964 965 966 967

	git_diff_list_free(diff);
	diff = NULL;

Russell Belfer committed
968 969
	cl_git_rewritefile("issue_1397/crlf_file.txt",
		"first line\r\nsecond line modified\r\nboth with crlf");
970 971 972

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

Russell Belfer committed
973 974 975
	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
976

Russell Belfer committed
977 978
	cl_assert_equal_i(1, exp.files);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
979

Russell Belfer committed
980
	cl_assert_equal_i(1, exp.hunks);
981

Russell Belfer committed
982 983 984 985
	cl_assert_equal_i(5, exp.lines);
	cl_assert_equal_i(3, exp.line_ctxt);
	cl_assert_equal_i(1, exp.line_adds);
	cl_assert_equal_i(1, exp.line_dels);
986 987 988 989 990 991

	git_diff_list_free(diff);
}

void test_diff_workdir__to_tree_issue_1397(void)
{
Russell Belfer committed
992
	const char *a_commit = "7f483a738"; /* the current HEAD */
993 994 995 996 997 998 999 1000
	git_tree *a;
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	git_diff_list *diff = NULL;
	git_diff_list *diff2 = NULL;
	diff_expects exp;

	g_repo = cl_git_sandbox_init("issue_1397");

Russell Belfer committed
1001
	cl_repo_set_bool(g_repo, "core.autocrlf", true);
1002 1003 1004 1005 1006 1007 1008 1009

	a = resolve_commit_oid_to_tree(g_repo, a_commit);

	opts.context_lines = 3;
	opts.interhunk_lines = 1;

	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));

Russell Belfer committed
1010 1011 1012
	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
1013

Russell Belfer committed
1014 1015 1016
	cl_assert_equal_i(0, exp.files);
	cl_assert_equal_i(0, exp.hunks);
	cl_assert_equal_i(0, exp.lines);
1017 1018 1019 1020 1021 1022 1023 1024 1025

	git_diff_list_free(diff);
	diff = NULL;

	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));
	cl_git_pass(git_diff_merge(diff, diff2));
	git_diff_list_free(diff2);

Russell Belfer committed
1026 1027 1028
	memset(&exp, 0, sizeof(exp));
	cl_git_pass(git_diff_foreach(
		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
1029

Russell Belfer committed
1030 1031 1032
	cl_assert_equal_i(0, exp.files);
	cl_assert_equal_i(0, exp.hunks);
	cl_assert_equal_i(0, exp.lines);
1033 1034 1035 1036

	git_diff_list_free(diff);
	git_tree_free(a);
}
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099

void test_diff_workdir__untracked_directory_scenarios(void)
{
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	git_diff_list *diff = NULL;
	diff_expects exp;
	char *pathspec = NULL;
	static const char *files0[] = {
		"subdir/deleted_file",
		"subdir/modified_file",
		"subdir/new_file",
		NULL
	};
	static const char *files1[] = {
		"subdir/deleted_file",
		"subdir/directory/",
		"subdir/modified_file",
		"subdir/new_file",
		NULL
	};
	static const char *files2[] = {
		"subdir/deleted_file",
		"subdir/directory/more/notignored",
		"subdir/modified_file",
		"subdir/new_file",
		NULL
	};

	g_repo = cl_git_sandbox_init("status");
	cl_git_mkfile("status/.gitignore", "ignored\n");

	opts.context_lines = 3;
	opts.interhunk_lines = 1;
	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
	opts.pathspec.strings = &pathspec;
	opts.pathspec.count   = 1;
	pathspec = "subdir";

	/* baseline for "subdir" pathspec */

	memset(&exp, 0, sizeof(exp));
	exp.names = files0;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(3, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* empty directory */

	cl_git_pass(p_mkdir("status/subdir/directory", 0777));

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* empty directory in empty directory */

	cl_git_pass(p_mkdir("status/subdir/directory/empty", 0777));

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* directory with only ignored files */

	cl_git_pass(p_mkdir("status/subdir/directory/deeper", 0777));
	cl_git_mkfile("status/subdir/directory/deeper/ignored", "ignore me\n");

	cl_git_pass(p_mkdir("status/subdir/directory/another", 0777));
	cl_git_mkfile("status/subdir/directory/another/ignored", "ignore me\n");

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* directory with ignored directory (contents irrelevant) */

	cl_git_pass(p_mkdir("status/subdir/directory/more", 0777));
	cl_git_pass(p_mkdir("status/subdir/directory/more/ignored", 0777));
	cl_git_mkfile("status/subdir/directory/more/ignored/notignored",
		"inside ignored dir\n");

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* quick version avoids directory scan */

	opts.flags = opts.flags | GIT_DIFF_FAST_UNTRACKED_DIRS;

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* directory with nested non-ignored content */

	opts.flags = opts.flags & ~GIT_DIFF_FAST_UNTRACKED_DIRS;

	cl_git_mkfile("status/subdir/directory/more/notignored",
		"not ignored deep under untracked\n");

	memset(&exp, 0, sizeof(exp));
	exp.names = files1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);

	/* use RECURSE_UNTRACKED_DIRS to get actual untracked files (no ignores) */

	opts.flags = opts.flags & ~GIT_DIFF_INCLUDE_IGNORED;
	opts.flags = opts.flags | GIT_DIFF_RECURSE_UNTRACKED_DIRS;

	memset(&exp, 0, sizeof(exp));
	exp.names = files2;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));

	cl_assert_equal_i(4, exp.files);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_UNTRACKED]);

	git_diff_list_free(diff);
}
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268


void test_diff_workdir__untracked_directory_comes_last(void)
{
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
	git_diff_list *diff = NULL;

	g_repo = cl_git_sandbox_init("renames");

	cl_git_mkfile("renames/.gitignore", "*.ign\n");
	cl_git_pass(p_mkdir("renames/zzz_untracked", 0777));
	cl_git_mkfile("renames/zzz_untracked/an.ign", "ignore me please");
	cl_git_mkfile("renames/zzz_untracked/skip.ign", "ignore me really");
	cl_git_mkfile("renames/zzz_untracked/test.ign", "ignore me now");

	opts.context_lines = 3;
	opts.interhunk_lines = 1;
	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	cl_assert(diff != NULL);

	git_diff_list_free(diff);
}