worktree.c 27.7 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "fileops.h"
3
#include "ignore.h"
4
#include "status_data.h"
5
#include "posix.h"
Russell Belfer committed
6 7
#include "util.h"
#include "path.h"
8
#include "../diff/diff_helpers.h"
9
#include "git2/sys/diff.h"
10 11 12 13 14 15 16

/**
 * Cleanup
 *
 * This will be called once after each test finishes, even
 * if the test failed
 */
17
void test_status_worktree__cleanup(void)
18
{
19
	cl_git_sandbox_cleanup();
20 21 22 23 24
}

/**
 * Tests - Status determination on a working tree
 */
Russell Belfer committed
25
/* this test is equivalent to t18-status.c:statuscb0 */
Vicent Marti committed
26
void test_status_worktree__whole_repository(void)
27
{
28
	status_entry_counts counts;
29
	git_repository *repo = cl_git_sandbox_init("status");
30

31
	memset(&counts, 0x0, sizeof(status_entry_counts));
32 33 34 35
	counts.expected_entry_count = entry_count0;
	counts.expected_paths = entry_paths0;
	counts.expected_statuses = entry_statuses0;

36
	cl_git_pass(
37
		git_status_foreach(repo, cb_status__normal, &counts)
38
	);
39

40 41 42
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
43 44
}

45 46 47 48 49 50 51
void assert_show(
	const int entry_counts,
	const char *entry_paths[],
	const unsigned int entry_statuses[],
	git_repository *repo,
	git_status_show_t show,
	unsigned int extra_flags)
52 53 54 55 56 57 58 59 60
{
	status_entry_counts counts;
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;

	memset(&counts, 0x0, sizeof(status_entry_counts));
	counts.expected_entry_count = entry_counts;
	counts.expected_paths = entry_paths;
	counts.expected_statuses = entry_statuses;

61
	opts.flags = GIT_STATUS_OPT_DEFAULTS | extra_flags;
62 63 64 65 66 67 68 69 70 71 72 73 74 75
	opts.show = show;

	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts)
	);

	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
}

void test_status_worktree__show_index_and_workdir(void)
{
	assert_show(entry_count0, entry_paths0, entry_statuses0,
76
		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
77 78 79 80 81
}

void test_status_worktree__show_index_only(void)
{
	assert_show(entry_count5, entry_paths5, entry_statuses5,
82
		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_INDEX_ONLY, 0);
83 84 85 86 87
}

void test_status_worktree__show_workdir_only(void)
{
	assert_show(entry_count6, entry_paths6, entry_statuses6,
88
		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_WORKDIR_ONLY, 0);
89 90
}

Russell Belfer committed
91
/* this test is equivalent to t18-status.c:statuscb1 */
Vicent Marti committed
92
void test_status_worktree__empty_repository(void)
93 94
{
	int count = 0;
95 96 97
	git_repository *repo = cl_git_sandbox_init("empty_standard_repo");

	cl_git_pass(git_status_foreach(repo, cb_status__count, &count));
98

99
	cl_assert_equal_i(0, count);
100
}
101

Russell Belfer committed
102 103 104 105 106 107 108 109 110 111
static int remove_file_cb(void *data, git_buf *file)
{
	const char *filename = git_buf_cstr(file);

	GIT_UNUSED(data);

	if (git__suffixcmp(filename, ".git") == 0)
		return 0;

	if (git_path_isdir(filename))
112
		cl_git_pass(git_futils_rmdir_r(filename, NULL, GIT_RMDIR_REMOVE_FILES));
Russell Belfer committed
113 114 115 116 117 118 119 120 121
	else
		cl_git_pass(p_unlink(git_buf_cstr(file)));

	return 0;
}

/* this test is equivalent to t18-status.c:statuscb2 */
void test_status_worktree__purged_worktree(void)
{
122
	status_entry_counts counts;
Russell Belfer committed
123 124 125 126 127
	git_repository *repo = cl_git_sandbox_init("status");
	git_buf workdir = GIT_BUF_INIT;

	/* first purge the contents of the worktree */
	cl_git_pass(git_buf_sets(&workdir, git_repository_workdir(repo)));
128
	cl_git_pass(git_path_direach(&workdir, 0, remove_file_cb, NULL));
129
	git_buf_free(&workdir);
Russell Belfer committed
130 131

	/* now get status */
132
	memset(&counts, 0x0, sizeof(status_entry_counts));
Russell Belfer committed
133 134 135 136 137 138 139 140
	counts.expected_entry_count = entry_count2;
	counts.expected_paths = entry_paths2;
	counts.expected_statuses = entry_statuses2;

	cl_git_pass(
		git_status_foreach(repo, cb_status__normal, &counts)
	);

141 142 143
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
Russell Belfer committed
144 145
}

146
/* this test is similar to t18-status.c:statuscb3 */
Russell Belfer committed
147 148
void test_status_worktree__swap_subdir_and_file(void)
{
149
	status_entry_counts counts;
Russell Belfer committed
150
	git_repository *repo = cl_git_sandbox_init("status");
151
	git_index *index;
152
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
153 154 155
	bool ignore_case;

	cl_git_pass(git_repository_index(&index, repo));
156
	ignore_case = (git_index_caps(index) & GIT_INDEXCAP_IGNORE_CASE) != 0;
157
	git_index_free(index);
Russell Belfer committed
158 159 160 161 162 163 164 165 166 167 168

	/* first alter the contents of the worktree */
	cl_git_pass(p_rename("status/current_file", "status/swap"));
	cl_git_pass(p_rename("status/subdir", "status/current_file"));
	cl_git_pass(p_rename("status/swap", "status/subdir"));

	cl_git_mkfile("status/.HEADER", "dummy");
	cl_git_mkfile("status/42-is-not-prime.sigh", "dummy");
	cl_git_mkfile("status/README.md", "dummy");

	/* now get status */
169
	memset(&counts, 0x0, sizeof(status_entry_counts));
Russell Belfer committed
170
	counts.expected_entry_count = entry_count3;
171 172
	counts.expected_paths = ignore_case ? entry_paths3_icase : entry_paths3;
	counts.expected_statuses = ignore_case ? entry_statuses3_icase : entry_statuses3;
Russell Belfer committed
173

174 175 176
	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
		GIT_STATUS_OPT_INCLUDE_IGNORED;

Russell Belfer committed
177
	cl_git_pass(
178
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts)
Russell Belfer committed
179 180
	);

181 182 183
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
Russell Belfer committed
184 185
}

186 187
void test_status_worktree__swap_subdir_with_recurse_and_pathspec(void)
{
188
	status_entry_counts counts;
189
	git_repository *repo = cl_git_sandbox_init("status");
190
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
191 192 193 194 195 196 197 198 199 200 201

	/* first alter the contents of the worktree */
	cl_git_pass(p_rename("status/current_file", "status/swap"));
	cl_git_pass(p_rename("status/subdir", "status/current_file"));
	cl_git_pass(p_rename("status/swap", "status/subdir"));
	cl_git_mkfile("status/.new_file", "dummy");
	cl_git_pass(git_futils_mkdir_r("status/zzz_new_dir", NULL, 0777));
	cl_git_mkfile("status/zzz_new_dir/new_file", "dummy");
	cl_git_mkfile("status/zzz_new_file", "dummy");

	/* now get status */
202
	memset(&counts, 0x0, sizeof(status_entry_counts));
203 204 205 206 207 208 209 210 211 212 213 214
	counts.expected_entry_count = entry_count4;
	counts.expected_paths = entry_paths4;
	counts.expected_statuses = entry_statuses4;

	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
	/* TODO: set pathspec to "current_file" eventually */

	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts)
	);

215 216 217
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
218 219
}

Russell Belfer committed
220
/* this test is equivalent to t18-status.c:singlestatus0 */
221 222 223 224
void test_status_worktree__single_file(void)
{
	int i;
	unsigned int status_flags;
225
	git_repository *repo = cl_git_sandbox_init("status");
226 227 228

	for (i = 0; i < (int)entry_count0; i++) {
		cl_git_pass(
229
			git_status_file(&status_flags, repo, entry_paths0[i])
230 231 232 233
		);
		cl_assert(entry_statuses0[i] == status_flags);
	}
}
234

Russell Belfer committed
235 236 237 238 239 240 241 242 243 244 245 246
/* this test is equivalent to t18-status.c:singlestatus1 */
void test_status_worktree__single_nonexistent_file(void)
{
	int error;
	unsigned int status_flags;
	git_repository *repo = cl_git_sandbox_init("status");

	error = git_status_file(&status_flags, repo, "nonexistent");
	cl_git_fail(error);
	cl_assert(error == GIT_ENOTFOUND);
}

247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
/* this test is equivalent to t18-status.c:singlestatus2 */
void test_status_worktree__single_nonexistent_file_empty_repo(void)
{
	int error;
	unsigned int status_flags;
	git_repository *repo = cl_git_sandbox_init("empty_standard_repo");

	error = git_status_file(&status_flags, repo, "nonexistent");
	cl_git_fail(error);
	cl_assert(error == GIT_ENOTFOUND);
}

/* this test is equivalent to t18-status.c:singlestatus3 */
void test_status_worktree__single_file_empty_repo(void)
{
	unsigned int status_flags;
	git_repository *repo = cl_git_sandbox_init("empty_standard_repo");

	cl_git_mkfile("empty_standard_repo/new_file", "new_file\n");

	cl_git_pass(git_status_file(&status_flags, repo, "new_file"));
	cl_assert(status_flags == GIT_STATUS_WT_NEW);
}

/* this test is equivalent to t18-status.c:singlestatus4 */
void test_status_worktree__single_folder(void)
{
	int error;
	unsigned int status_flags;
	git_repository *repo = cl_git_sandbox_init("status");

	error = git_status_file(&status_flags, repo, "subdir");
	cl_git_fail(error);
280
	cl_assert(error != GIT_ENOTFOUND);
281 282
}

Russell Belfer committed
283

284 285 286
void test_status_worktree__ignores(void)
{
	int i, ignored;
287
	git_repository *repo = cl_git_sandbox_init("status");
288 289

	for (i = 0; i < (int)entry_count0; i++) {
290
		cl_git_pass(
291
			git_status_should_ignore(&ignored, repo, entry_paths0[i])
292
		);
293
		cl_assert(ignored == (entry_statuses0[i] == GIT_STATUS_IGNORED));
294 295
	}

296
	cl_git_pass(
297
		git_status_should_ignore(&ignored, repo, "nonexistent_file")
298
	);
299 300
	cl_assert(!ignored);

301
	cl_git_pass(
302
		git_status_should_ignore(&ignored, repo, "ignored_nonexistent_file")
303
	);
304 305
	cl_assert(ignored);
}
306 307 308

static int cb_status__check_592(const char *p, unsigned int s, void *payload)
{
309 310
	if (s != GIT_STATUS_WT_DELETED ||
		(payload != NULL && strcmp(p, (const char *)payload) != 0))
311 312 313 314 315 316 317 318 319 320 321 322 323
		return -1;

	return 0;
}

void test_status_worktree__issue_592(void)
{
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;

	repo = cl_git_sandbox_init("issue_592");
	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "l.txt"));
	cl_git_pass(p_unlink(git_buf_cstr(&path)));
324
	cl_assert(!git_path_exists("issue_592/l.txt"));
325 326 327 328 329 330 331 332 333 334 335 336 337 338

	cl_git_pass(git_status_foreach(repo, cb_status__check_592, "l.txt"));

	git_buf_free(&path);
}

void test_status_worktree__issue_592_2(void)
{
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;

	repo = cl_git_sandbox_init("issue_592");
	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "c/a.txt"));
	cl_git_pass(p_unlink(git_buf_cstr(&path)));
339
	cl_assert(!git_path_exists("issue_592/c/a.txt"));
340 341 342 343 344 345 346 347 348 349 350 351 352 353

	cl_git_pass(git_status_foreach(repo, cb_status__check_592, "c/a.txt"));

	git_buf_free(&path);
}

void test_status_worktree__issue_592_3(void)
{
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;

	repo = cl_git_sandbox_init("issue_592");

	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "c"));
354
	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
355
	cl_assert(!git_path_exists("issue_592/c/a.txt"));
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

	cl_git_pass(git_status_foreach(repo, cb_status__check_592, "c/a.txt"));

	git_buf_free(&path);
}

void test_status_worktree__issue_592_4(void)
{
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;

	repo = cl_git_sandbox_init("issue_592");

	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "t/b.txt"));
	cl_git_pass(p_unlink(git_buf_cstr(&path)));

	cl_git_pass(git_status_foreach(repo, cb_status__check_592, "t/b.txt"));

	git_buf_free(&path);
}

void test_status_worktree__issue_592_5(void)
{
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;

	repo = cl_git_sandbox_init("issue_592");

	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(repo), "t"));
385
	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
386 387 388 389 390 391
	cl_git_pass(p_mkdir(git_buf_cstr(&path), 0777));

	cl_git_pass(git_status_foreach(repo, cb_status__check_592, NULL));

	git_buf_free(&path);
}
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 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
void test_status_worktree__issue_592_ignores_0(void)
{
	int count = 0;
	status_entry_single st;
	git_repository *repo = cl_git_sandbox_init("issue_592");

	cl_git_pass(git_status_foreach(repo, cb_status__count, &count));
	cl_assert_equal_i(0, count);

	cl_git_rewritefile("issue_592/.gitignore",
		".gitignore\n*.txt\nc/\n[tT]*/\n");

	cl_git_pass(git_status_foreach(repo, cb_status__count, &count));
	cl_assert_equal_i(1, count);

	/* This is a situation where the behavior of libgit2 is
	 * different from core git.  Core git will show ignored.txt
	 * in the list of ignored files, even though the directory
	 * "t" is ignored and the file is untracked because we have
	 * the explicit "*.txt" ignore rule.  Libgit2 just excludes
	 * all untracked files that are contained within ignored
	 * directories without explicitly listing them.
	 */
	cl_git_rewritefile("issue_592/t/ignored.txt", "ping");

	memset(&st, 0, sizeof(st));
	cl_git_pass(git_status_foreach(repo, cb_status__single, &st));
	cl_assert_equal_i(1, st.count);
	cl_assert(st.status == GIT_STATUS_IGNORED);

	cl_git_rewritefile("issue_592/c/ignored_by_dir", "ping");

	memset(&st, 0, sizeof(st));
	cl_git_pass(git_status_foreach(repo, cb_status__single, &st));
	cl_assert_equal_i(1, st.count);
	cl_assert(st.status == GIT_STATUS_IGNORED);

	cl_git_rewritefile("issue_592/t/ignored_by_dir_pattern", "ping");

	memset(&st, 0, sizeof(st));
	cl_git_pass(git_status_foreach(repo, cb_status__single, &st));
	cl_assert_equal_i(1, st.count);
	cl_assert(st.status == GIT_STATUS_IGNORED);
}

void test_status_worktree__issue_592_ignored_dirs_with_tracked_content(void)
{
	int count = 0;
	git_repository *repo = cl_git_sandbox_init("issue_592b");

	cl_git_pass(git_status_foreach(repo, cb_status__count, &count));
	cl_assert_equal_i(1, count);

	/* if we are really mimicking core git, then only ignored1.txt
	 * at the top level will show up in the ignores list here.
	 * everything else will be unmodified or skipped completely.
	 */
}

Vicent Marti committed
452
void test_status_worktree__conflict_with_diff3(void)
453
{
Vicent Marti committed
454
	git_repository *repo = cl_git_sandbox_init("status");
455
	git_index *index;
Vicent Marti committed
456 457
	unsigned int status;
	git_index_entry ancestor_entry, our_entry, their_entry;
458

Vicent Marti committed
459 460 461
	memset(&ancestor_entry, 0x0, sizeof(git_index_entry));
	memset(&our_entry, 0x0, sizeof(git_index_entry));
	memset(&their_entry, 0x0, sizeof(git_index_entry));
462

Vicent Marti committed
463
	ancestor_entry.path = "modified_file";
464
	git_oid_fromstr(&ancestor_entry.id,
Vicent Marti committed
465
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
466

Vicent Marti committed
467
	our_entry.path = "modified_file";
468
	git_oid_fromstr(&our_entry.id,
Vicent Marti committed
469
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
470

Vicent Marti committed
471
	their_entry.path = "modified_file";
472
	git_oid_fromstr(&their_entry.id,
Vicent Marti committed
473
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
474

Vicent Marti committed
475 476
	cl_git_pass(git_status_file(&status, repo, "modified_file"));
	cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status);
477 478

	cl_git_pass(git_repository_index(&index, repo));
Vicent Marti committed
479
	cl_git_pass(git_index_remove(index, "modified_file", 0));
480 481 482 483
	cl_git_pass(git_index_conflict_add(
		index, &ancestor_entry, &our_entry, &their_entry));
	cl_git_pass(git_index_write(index));
	git_index_free(index);
484

Vicent Marti committed
485
	cl_git_pass(git_status_file(&status, repo, "modified_file"));
486

Vicent Marti committed
487
	cl_assert_equal_i(GIT_STATUS_INDEX_DELETED | GIT_STATUS_WT_NEW, status);
488
}
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511

static const char *filemode_paths[] = {
	"exec_off",
	"exec_off2on_staged",
	"exec_off2on_workdir",
	"exec_off_untracked",
	"exec_on",
	"exec_on2off_staged",
	"exec_on2off_workdir",
	"exec_on_untracked",
};

static unsigned int filemode_statuses[] = {
	GIT_STATUS_CURRENT,
	GIT_STATUS_INDEX_MODIFIED,
	GIT_STATUS_WT_MODIFIED,
	GIT_STATUS_WT_NEW,
	GIT_STATUS_CURRENT,
	GIT_STATUS_INDEX_MODIFIED,
	GIT_STATUS_WT_MODIFIED,
	GIT_STATUS_WT_NEW
};

512
static const int filemode_count = 8;
513 514 515 516 517

void test_status_worktree__filemode_changes(void)
{
	git_repository *repo = cl_git_sandbox_init("filemodes");
	status_entry_counts counts;
518
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
519 520 521

	/* overwrite stored filemode with platform appropriate value */
	if (cl_is_chmod_supported())
522
		cl_repo_set_bool(repo, "core.filemode", true);
523
	else {
524
		int i;
525 526

		cl_repo_set_bool(repo, "core.filemode", false);
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

		/* won't trust filesystem mode diffs, so these will appear unchanged */
		for (i = 0; i < filemode_count; ++i)
			if (filemode_statuses[i] == GIT_STATUS_WT_MODIFIED)
				filemode_statuses[i] = GIT_STATUS_CURRENT;
	}

	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
		GIT_STATUS_OPT_INCLUDE_IGNORED |
		GIT_STATUS_OPT_INCLUDE_UNMODIFIED;

	memset(&counts, 0, sizeof(counts));
	counts.expected_entry_count = filemode_count;
	counts.expected_paths = filemode_paths;
	counts.expected_statuses = filemode_statuses;

	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts)
	);

	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
}
551

552 553 554 555 556 557 558 559 560
static int cb_status__interrupt(const char *p, unsigned int s, void *payload)
{
	volatile int *count = (int *)payload;

	GIT_UNUSED(p);
	GIT_UNUSED(s);

	(*count)++;

561
	return (*count == 8) ? -111 : 0;
562 563 564 565 566 567 568 569
}

void test_status_worktree__interruptable_foreach(void)
{
	int count = 0;
	git_repository *repo = cl_git_sandbox_init("status");

	cl_assert_equal_i(
570
		-111, git_status_foreach(repo, cb_status__interrupt, &count)
571 572 573 574
	);

	cl_assert_equal_i(8, count);
}
575

576 577 578 579 580
void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf(void)
{
	git_repository *repo = cl_git_sandbox_init("status");
	unsigned int status;

581
	cl_repo_set_bool(repo, "core.autocrlf", true);
582 583 584 585 586

	cl_git_rewritefile("status/current_file", "current_file\r\n");

	cl_git_pass(git_status_file(&status, repo, "current_file"));

587 588 589 590 591
	/* stat data on file should no longer match stat cache, even though
	 * file diff will be empty because of line-ending conversion - matches
	 * the Git command-line behavior here.
	 */
	cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status);
592
}
593

594 595 596 597 598
void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf_issue_1397(void)
{
	git_repository *repo = cl_git_sandbox_init("issue_1397");
	unsigned int status;

Russell Belfer committed
599
	cl_repo_set_bool(repo, "core.autocrlf", true);
600 601 602 603 604 605

	cl_git_pass(git_status_file(&status, repo, "crlf_file.txt"));

	cl_assert_equal_i(GIT_STATUS_CURRENT, status);
}

606 607 608 609 610 611 612 613 614 615 616 617
void test_status_worktree__conflicted_item(void)
{
	git_repository *repo = cl_git_sandbox_init("status");
	git_index *index;
	unsigned int status;
	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 = "modified_file";
618
	git_oid_fromstr(&ancestor_entry.id,
619 620 621
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");

	our_entry.path = "modified_file";
622
	git_oid_fromstr(&our_entry.id,
623 624 625
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");

	their_entry.path = "modified_file";
626
	git_oid_fromstr(&their_entry.id,
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");

	cl_git_pass(git_status_file(&status, repo, "modified_file"));
	cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status);

	cl_git_pass(git_repository_index(&index, repo));
	cl_git_pass(git_index_conflict_add(index, &ancestor_entry,
		&our_entry, &their_entry));

	cl_git_pass(git_status_file(&status, repo, "modified_file"));
	cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status);

	git_index_free(index);
}

642 643 644 645 646
static void stage_and_commit(git_repository *repo, const char *path)
{
	git_index *index;

	cl_git_pass(git_repository_index(&index, repo));
647
	cl_git_pass(git_index_add_bypath(index, path));
648
	cl_repo_commit_from_index(NULL, repo, NULL, 1323847743, "Initial commit\n");
649 650 651 652 653 654 655 656 657
	git_index_free(index);
}

static void assert_ignore_case(
	bool should_ignore_case,
	int expected_lower_cased_file_status,
	int expected_camel_cased_file_status)
{
	unsigned int status;
658
	git_buf lower_case_path = GIT_BUF_INIT, camel_case_path = GIT_BUF_INIT;
659
	git_repository *repo, *repo2;
660

661 662 663
	repo = cl_git_sandbox_init("empty_standard_repo");
	cl_git_remove_placeholders(git_repository_path(repo), "dummy-marker.txt");

664
	cl_repo_set_bool(repo, "core.ignorecase", should_ignore_case);
665 666 667 668 669 670 671 672 673 674 675 676 677

	cl_git_pass(git_buf_joinpath(&lower_case_path,
		git_repository_workdir(repo), "plop"));

	cl_git_mkfile(git_buf_cstr(&lower_case_path), "");

	stage_and_commit(repo, "plop");

	cl_git_pass(git_repository_open(&repo2, "./empty_standard_repo"));

	cl_git_pass(git_status_file(&status, repo2, "plop"));
	cl_assert_equal_i(GIT_STATUS_CURRENT, status);

678 679 680
	cl_git_pass(git_buf_joinpath(&camel_case_path,
		git_repository_workdir(repo), "Plop"));

681 682 683 684 685 686 687 688 689 690 691 692 693
	cl_git_pass(p_rename(git_buf_cstr(&lower_case_path), git_buf_cstr(&camel_case_path)));

	cl_git_pass(git_status_file(&status, repo2, "plop"));
	cl_assert_equal_i(expected_lower_cased_file_status, status);

	cl_git_pass(git_status_file(&status, repo2, "Plop"));
	cl_assert_equal_i(expected_camel_cased_file_status, status);

	git_repository_free(repo2);
	git_buf_free(&lower_case_path);
	git_buf_free(&camel_case_path);
}

694
void test_status_worktree__file_status_honors_core_ignorecase_true(void)
695 696 697 698
{
	assert_ignore_case(true, GIT_STATUS_CURRENT, GIT_STATUS_CURRENT);
}

699
void test_status_worktree__file_status_honors_core_ignorecase_false(void)
700 701 702
{
	assert_ignore_case(false, GIT_STATUS_WT_DELETED, GIT_STATUS_WT_NEW);
}
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

void test_status_worktree__file_status_honors_case_ignorecase_regarding_untracked_files(void)
{
    git_repository *repo = cl_git_sandbox_init("status");
    unsigned int status;
    git_index *index;

    cl_repo_set_bool(repo, "core.ignorecase", false);

	repo = cl_git_sandbox_reopen();

    /* Actually returns GIT_STATUS_IGNORED on Windows */
    cl_git_fail_with(git_status_file(&status, repo, "NEW_FILE"), GIT_ENOTFOUND);

    cl_git_pass(git_repository_index(&index, repo));

    cl_git_pass(git_index_add_bypath(index, "new_file"));
    cl_git_pass(git_index_write(index));
    git_index_free(index);

    /* Actually returns GIT_STATUS_IGNORED on Windows */
    cl_git_fail_with(git_status_file(&status, repo, "NEW_FILE"), GIT_ENOTFOUND);
}
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773

void test_status_worktree__simple_delete(void)
{
    git_repository *repo = cl_git_sandbox_init("renames");
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
	int count;

	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
		GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH |
		GIT_STATUS_OPT_EXCLUDE_SUBMODULES |
		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;

	count = 0;
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__count, &count) );
	cl_assert_equal_i(0, count);

	cl_must_pass(p_unlink("renames/untimely.txt"));

	count = 0;
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__count, &count) );
	cl_assert_equal_i(1, count);
}

void test_status_worktree__simple_delete_indexed(void)
{
	git_repository *repo = cl_git_sandbox_init("renames");
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
	git_status_list *status;

	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
		GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH |
		GIT_STATUS_OPT_EXCLUDE_SUBMODULES |
		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;

	cl_git_pass(git_status_list_new(&status, repo, &opts));
	cl_assert_equal_sz(0, git_status_list_entrycount(status));
	git_status_list_free(status);

	cl_must_pass(p_unlink("renames/untimely.txt"));

	cl_git_pass(git_status_list_new(&status, repo, &opts));
	cl_assert_equal_sz(1, git_status_list_entrycount(status));
	cl_assert_equal_i(
		GIT_STATUS_WT_DELETED, git_status_byindex(status, 0)->status);
	git_status_list_free(status);
}
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853

static const char *icase_paths[] = { "B", "c", "g", "H" };
static unsigned int icase_statuses[] = {
	GIT_STATUS_WT_MODIFIED, GIT_STATUS_WT_DELETED,
	GIT_STATUS_WT_MODIFIED, GIT_STATUS_WT_DELETED,
};

static const char *case_paths[] = { "B", "H", "c", "g" };
static unsigned int case_statuses[] = {
	GIT_STATUS_WT_MODIFIED, GIT_STATUS_WT_DELETED,
	GIT_STATUS_WT_DELETED, GIT_STATUS_WT_MODIFIED,
};

void test_status_worktree__sorting_by_case(void)
{
	git_repository *repo = cl_git_sandbox_init("icase");
	git_index *index;
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
	bool native_ignore_case;
	status_entry_counts counts;

	cl_git_pass(git_repository_index(&index, repo));
	native_ignore_case =
		(git_index_caps(index) & GIT_INDEXCAP_IGNORE_CASE) != 0;
	git_index_free(index);

	memset(&counts, 0, sizeof(counts));
	counts.expected_entry_count = 0;
	counts.expected_paths = NULL;
	counts.expected_statuses = NULL;
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts));
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);

	cl_git_rewritefile("icase/B", "new stuff");
	cl_must_pass(p_unlink("icase/c"));
	cl_git_rewritefile("icase/g", "new stuff");
	cl_must_pass(p_unlink("icase/H"));

	memset(&counts, 0, sizeof(counts));
	counts.expected_entry_count = 4;
	if (native_ignore_case) {
		counts.expected_paths = icase_paths;
		counts.expected_statuses = icase_statuses;
	} else {
		counts.expected_paths = case_paths;
		counts.expected_statuses = case_statuses;
	}
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts));
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);

	opts.flags = GIT_STATUS_OPT_SORT_CASE_SENSITIVELY;

	memset(&counts, 0, sizeof(counts));
	counts.expected_entry_count = 4;
	counts.expected_paths = case_paths;
	counts.expected_statuses = case_statuses;
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts));
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);

	opts.flags = GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY;

	memset(&counts, 0, sizeof(counts));
	counts.expected_entry_count = 4;
	counts.expected_paths = icase_paths;
	counts.expected_statuses = icase_statuses;
	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts));
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
}
854 855 856

void test_status_worktree__long_filenames(void)
{
857
	char path[260*4+1];
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
	const char *expected_paths[] = {path};
	const unsigned int expected_statuses[] = {GIT_STATUS_WT_NEW};

	git_repository *repo = cl_git_sandbox_init("empty_standard_repo");
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
	status_entry_counts counts = {0};

	// Create directory with amazingly long filename
	sprintf(path, "empty_standard_repo/%s", longname);
	cl_git_pass(git_futils_mkdir_r(path, NULL, 0777));
	sprintf(path, "empty_standard_repo/%s/foo", longname);
	cl_git_mkfile(path, "dummy");

	sprintf(path, "%s/foo", longname);
	counts.expected_entry_count = 1;
	counts.expected_paths = expected_paths;
	counts.expected_statuses = expected_statuses;

	opts.show = GIT_STATUS_SHOW_WORKDIR_ONLY;
	opts.flags = GIT_STATUS_OPT_DEFAULTS;

	cl_git_pass(
		git_status_foreach_ext(repo, &opts, cb_status__normal, &counts) );
	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
	cl_assert_equal_i(0, counts.wrong_status_flags_count);
	cl_assert_equal_i(0, counts.wrong_sorted_path);
}

886 887 888 889 890
/* The update stat cache tests mostly just mirror other tests and try
 * to make sure that updating the stat cache doesn't change the results
 * while reducing the amount of work that needs to be done
 */

891 892 893 894 895 896 897 898 899 900
static void check_status0(git_status_list *status)
{
	size_t i, max_i = git_status_list_entrycount(status);
	cl_assert_equal_sz(entry_count0, max_i);
	for (i = 0; i < max_i; ++i) {
		const git_status_entry *entry = git_status_byindex(status, i);
		cl_assert_equal_i(entry_statuses0[i], entry->status);
	}
}

901 902 903
void test_status_worktree__update_stat_cache_0(void)
{
	git_repository *repo = cl_git_sandbox_init("status");
904 905 906
	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
	git_status_list *status;
	git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
907

908
	opts.flags = GIT_STATUS_OPT_DEFAULTS;
909

910 911 912 913 914
	cl_git_pass(git_status_list_new(&status, repo, &opts));
	check_status0(status);
	cl_git_pass(git_status_list_get_perfdata(&perf, status));
	cl_assert_equal_sz(13 + 3, perf.stat_calls);
	cl_assert_equal_sz(5, perf.oid_calculations);
915

916
	git_status_list_free(status);
917

918 919 920 921 922 923 924
	opts.flags |= GIT_STATUS_OPT_UPDATE_INDEX;

	cl_git_pass(git_status_list_new(&status, repo, &opts));
	check_status0(status);
	cl_git_pass(git_status_list_get_perfdata(&perf, status));
	cl_assert_equal_sz(13 + 3, perf.stat_calls);
	cl_assert_equal_sz(5, perf.oid_calculations);
925

926
	git_status_list_free(status);
927

928
	opts.flags &= ~GIT_STATUS_OPT_UPDATE_INDEX;
929

930 931 932 933 934
	cl_git_pass(git_status_list_new(&status, repo, &opts));
	check_status0(status);
	cl_git_pass(git_status_list_get_perfdata(&perf, status));
	cl_assert_equal_sz(13 + 3, perf.stat_calls);
	cl_assert_equal_sz(0, perf.oid_calculations);
935

936
	git_status_list_free(status);
937
}