thodg/libgit2/tests/status/ignore.c

• Show log

  Commit

• Hash : 17820381
  Author :
  Date : 2013-11-14T14:05:52
  

  Rename tests-clar to tests

Download

• tests/status/ignore.c

• #include "clar_libgit2.h"
  #include "fileops.h"
  #include "git2/attr.h"
  #include "ignore.h"
  #include "attr.h"
  #include "status_helpers.h"
  
  static git_repository *g_repo = NULL;
  
  void test_status_ignore__initialize(void)
  {
  }
  
  void test_status_ignore__cleanup(void)
  {
  	cl_git_sandbox_cleanup();
  }
  
  void test_status_ignore__0(void)
  {
  	struct {
  		const char *path;
  		int expected;
  	} test_cases[] = {
  		/* pattern "ign" from .gitignore */
  		{ "file", 0 },
  		{ "ign", 1 },
  		{ "sub", 0 },
  		{ "sub/file", 0 },
  		{ "sub/ign", 1 },
  		{ "sub/ign/file", 1 },
  		{ "sub/ign/sub", 1 },
  		{ "sub/ign/sub/file", 1 },
  		{ "sub/sub", 0 },
  		{ "sub/sub/file", 0 },
  		{ "sub/sub/ign", 1 },
  		{ "sub/sub/sub", 0 },
  		/* pattern "dir/" from .gitignore */
  		{ "dir", 1 },
  		{ "dir/", 1 },
  		{ "sub/dir", 1 },
  		{ "sub/dir/", 1 },
  		{ "sub/dir/file", 1 }, /* contained in ignored parent */
  		{ "sub/sub/dir", 0 }, /* dir is not actually a dir, but a file */
  		{ NULL, 0 }
  	}, *one_test;
  
  	g_repo = cl_git_sandbox_init("attr");
  
  	for (one_test = test_cases; one_test->path != NULL; one_test++) {
  		int ignored;
  		cl_git_pass(git_status_should_ignore(&ignored, g_repo, one_test->path));
  		cl_assert_(ignored == one_test->expected, one_test->path);
  	}
  
  	/* confirm that ignore files were cached */
  	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/exclude"));
  	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitignore"));
  }
  
  
  void test_status_ignore__1(void)
  {
  	int ignored;
  
  	g_repo = cl_git_sandbox_init("attr");
  
  	cl_git_rewritefile("attr/.gitignore", "/*.txt\n/dir/\n");
  	git_attr_cache_flush(g_repo);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "root_test4.txt"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/subdir_test2.txt"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "dir"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "dir/"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/dir"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/dir/"));
  	cl_assert(!ignored);
  }
  
  
  void test_status_ignore__empty_repo_with_gitignore_rewrite(void)
  {
  	status_entry_single st;
  	int ignored;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_mkfile(
  		"empty_standard_repo/look-ma.txt", "I'm going to be ignored!");
  
  	memset(&st, 0, sizeof(st));
  	cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st));
  	cl_assert(st.count == 1);
  	cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
  	cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
  	cl_assert(!ignored);
  
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "*.nomatch\n");
  
  	memset(&st, 0, sizeof(st));
  	cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st));
  	cl_assert(st.count == 2);
  	cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
  	cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
  	cl_assert(!ignored);
  
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "*.txt\n");
  
  	memset(&st, 0, sizeof(st));
  	cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st));
  	cl_assert(st.count == 2);
  	cl_assert(st.status == GIT_STATUS_IGNORED);
  
  	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
  	cl_assert(st.status == GIT_STATUS_IGNORED);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
  	cl_assert(ignored);
  }
  
  void test_status_ignore__ignore_pattern_contains_space(void)
  {
  	unsigned int flags;
  	const mode_t mode = 0777;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "foo bar.txt\n");
  
  	cl_git_mkfile(
  		"empty_standard_repo/foo bar.txt", "I'm going to be ignored!");
  
  	cl_git_pass(git_status_file(&flags, g_repo, "foo bar.txt"));
  	cl_assert(flags == GIT_STATUS_IGNORED);
  
  	cl_git_pass(git_futils_mkdir_r("empty_standard_repo/foo", NULL, mode));
  	cl_git_mkfile("empty_standard_repo/foo/look-ma.txt", "I'm not going to be ignored!");
  
  	cl_git_pass(git_status_file(&flags, g_repo, "foo/look-ma.txt"));
  	cl_assert(flags == GIT_STATUS_WT_NEW);
  }
  
  void test_status_ignore__ignore_pattern_ignorecase(void)
  {
  	unsigned int flags;
  	bool ignore_case;
  	git_index *index;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "a.txt\n");
  
  	cl_git_mkfile("empty_standard_repo/A.txt", "Differs in case");
  
  	cl_git_pass(git_repository_index(&index, g_repo));
  	ignore_case = (git_index_caps(index) & GIT_INDEXCAP_IGNORE_CASE) != 0;
  	git_index_free(index);
  
  	cl_git_pass(git_status_file(&flags, g_repo, "A.txt"));
  	cl_assert(flags == ignore_case ? GIT_STATUS_IGNORED : GIT_STATUS_WT_NEW);
  }
  
  void test_status_ignore__subdirectories(void)
  {
  	status_entry_single st;
  	int ignored;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_mkfile(
  		"empty_standard_repo/ignore_me", "I'm going to be ignored!");
  
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n");
  
  	memset(&st, 0, sizeof(st));
  	cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st));
  	cl_assert_equal_i(2, st.count);
  	cl_assert(st.status == GIT_STATUS_IGNORED);
  
  	cl_git_pass(git_status_file(&st.status, g_repo, "ignore_me"));
  	cl_assert(st.status == GIT_STATUS_IGNORED);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "ignore_me"));
  	cl_assert(ignored);
  
  	/* I've changed libgit2 so that the behavior here now differs from
  	 * core git but seems to make more sense.  In core git, the following
  	 * items are skipped completed, even if --ignored is passed to status.
  	 * It you mirror these steps and run "git status -uall --ignored" then
  	 * you will not see "test/ignore_me/" in the results.
  	 *
  	 * However, we had a couple reports of this as a bug, plus there is a
  	 * similar circumstance where we were differing for core git when you
  	 * used a rooted path for an ignore, so I changed this behavior.
  	 */
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/test/ignore_me", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/test/ignore_me/file", "I'm going to be ignored!");
  	cl_git_mkfile(
  		"empty_standard_repo/test/ignore_me/file2", "Me, too!");
  
  	memset(&st, 0, sizeof(st));
  	cl_git_pass(git_status_foreach(g_repo, cb_status__single, &st));
  	cl_assert_equal_i(3, st.count);
  
  	cl_git_pass(git_status_file(&st.status, g_repo, "test/ignore_me/file"));
  	cl_assert(st.status == GIT_STATUS_IGNORED);
  
  	cl_git_pass(
  		git_status_should_ignore(&ignored, g_repo, "test/ignore_me/file"));
  	cl_assert(ignored);
  }
  
  void test_status_ignore__subdirectories_recursion(void)
  {
  	/* Let's try again with recursing into ignored dirs turned on */
  	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
  	status_entry_counts counts;
  	static const char *paths_r[] = {
  		".gitignore",
  		"ignore_also/file",
  		"ignore_me",
  		"test/ignore_me/and_me/file",
  		"test/ignore_me/file",
  		"test/ignore_me/file2",
  	};
  	static const unsigned int statuses_r[] = {
  		GIT_STATUS_WT_NEW,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  	};
  	static const char *paths_nr[] = {
  		".gitignore",
  		"ignore_also/",
  		"ignore_me",
  		"test/ignore_me/",
  	};
  	static const unsigned int statuses_nr[] = {
  		GIT_STATUS_WT_NEW,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  		GIT_STATUS_IGNORED,
  	};
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n/ignore_also\n");
  
  	cl_git_mkfile(
  		"empty_standard_repo/ignore_me", "I'm going to be ignored!");
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/test/ignore_me", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/test/ignore_me/file", "I'm going to be ignored!");
  	cl_git_mkfile(
  		"empty_standard_repo/test/ignore_me/file2", "Me, too!");
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/test/ignore_me/and_me", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/test/ignore_me/and_me/file", "Deeply ignored");
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/ignore_also", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/ignore_also/file", "I'm going to be ignored!");
  
  	memset(&counts, 0x0, sizeof(status_entry_counts));
  	counts.expected_entry_count = 6;
  	counts.expected_paths = paths_r;
  	counts.expected_statuses = statuses_r;
  
  	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
  
  	cl_git_pass(git_status_foreach_ext(
  		g_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);
  
  
  	memset(&counts, 0x0, sizeof(status_entry_counts));
  	counts.expected_entry_count = 4;
  	counts.expected_paths = paths_nr;
  	counts.expected_statuses = statuses_nr;
  
  	opts.flags = GIT_STATUS_OPT_DEFAULTS;
  
  	cl_git_pass(git_status_foreach_ext(
  		g_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_ignore__adding_internal_ignores(void)
  {
  	int ignored;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_ignore_add_rule(g_repo, "*.nomatch\n"));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_ignore_add_rule(g_repo, "*.txt\n"));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_ignore_add_rule(g_repo, "*.bar\n"));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_ignore_clear_internal_rules(g_repo));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_ignore_add_rule(
  		g_repo, "multiple\n*.rules\n# comment line\n*.bar\n"));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(ignored);
  }
  
  void test_status_ignore__add_internal_as_first_thing(void)
  {
  	int ignored;
  	const char *add_me = "\n#################\n## Eclipse\n#################\n\n*.pydevproject\n.project\n.metadata\nbin/\ntmp/\n*.tmp\n\n";
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_pass(git_ignore_add_rule(g_repo, add_me));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.tmp"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
  	cl_assert(!ignored);
  }
  
  void test_status_ignore__internal_ignores_inside_deep_paths(void)
  {
  	int ignored;
  	const char *add_me = "Debug\nthis/is/deep\npatterned*/dir\n";
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_pass(git_ignore_add_rule(g_repo, add_me));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "Debug"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/Debug"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "really/Debug/this/file"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "Debug/what/I/say"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/NoDebug"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "NoDebug/this"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "please/NoDebug/this"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deep"));
  	cl_assert(ignored);
  	/* pattern containing slash gets FNM_PATHNAME so all slashes must match */
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/this/is/deep"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deep/too"));
  	cl_assert(ignored);
  	/* pattern containing slash gets FNM_PATHNAME so all slashes must match */
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "but/this/is/deep/and/ignored"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/not/deep"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "is/this/not/as/deep"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deepish"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "xthis/is/deep"));
  	cl_assert(!ignored);
  }
  
  void test_status_ignore__automatically_ignore_bad_files(void)
  {
  	int ignored;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_ignore_add_rule(g_repo, "*.c\n"));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_ignore_clear_internal_rules(g_repo));
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
  	cl_assert(ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
  	cl_assert(!ignored);
  }
  
  void test_status_ignore__filenames_with_special_prefixes_do_not_interfere_with_status_retrieval(void)
  {
  	status_entry_single st;
  	char *test_cases[] = {
  		"!file",
  		"#blah",
  		"[blah]",
  		"[attr]",
  		"[attr]blah",
  		NULL
  	};
  	int i;
  
  	for (i = 0; *(test_cases + i) != NULL; i++) {
  		git_buf file = GIT_BUF_INIT;
  		char *file_name = *(test_cases + i);
  		git_repository *repo = cl_git_sandbox_init("empty_standard_repo");
  
  		cl_git_pass(git_buf_joinpath(&file, "empty_standard_repo", file_name));
  		cl_git_mkfile(git_buf_cstr(&file), "Please don't ignore me!");
  
  		memset(&st, 0, sizeof(st));
  		cl_git_pass(git_status_foreach(repo, cb_status__single, &st));
  		cl_assert(st.count == 1);
  		cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  		cl_git_pass(git_status_file(&st.status, repo, file_name));
  		cl_assert(st.status == GIT_STATUS_WT_NEW);
  
  		cl_git_sandbox_cleanup();
  		git_buf_free(&file);
  	}
  }
  
  void test_status_ignore__issue_1766_negated_ignores(void)
  {
  	int ignored = 0;
  	unsigned int status;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/a", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/a/.gitignore", "*\n!.gitignore\n");
  	cl_git_mkfile(
  		"empty_standard_repo/a/ignoreme", "I should be ignored\n");
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/.gitignore"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/ignoreme"));
  	cl_assert(ignored);
  
  	cl_git_pass(git_futils_mkdir_r(
  		"empty_standard_repo/b", NULL, 0775));
  	cl_git_mkfile(
  		"empty_standard_repo/b/.gitignore", "*\n!.gitignore\n");
  	cl_git_mkfile(
  		"empty_standard_repo/b/ignoreme", "I should be ignored\n");
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "b/.gitignore"));
  	cl_assert(!ignored);
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "b/ignoreme"));
  	cl_assert(ignored);
  
  	/* shouldn't have changed results from first couple either */
  
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/.gitignore"));
  	cl_assert(!ignored);
  	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/ignoreme"));
  	cl_assert(ignored);
  
  	/* status should find the two ignore files and nothing else */
  
  	cl_git_pass(git_status_file(&status, g_repo, "a/.gitignore"));
  	cl_assert_equal_i(GIT_STATUS_WT_NEW, (int)status);
  
  	cl_git_pass(git_status_file(&status, g_repo, "a/ignoreme"));
  	cl_assert_equal_i(GIT_STATUS_IGNORED, (int)status);
  
  	cl_git_pass(git_status_file(&status, g_repo, "b/.gitignore"));
  	cl_assert_equal_i(GIT_STATUS_WT_NEW, (int)status);
  
  	cl_git_pass(git_status_file(&status, g_repo, "b/ignoreme"));
  	cl_assert_equal_i(GIT_STATUS_IGNORED, (int)status);
  
  	{
  		git_status_options opts = GIT_STATUS_OPTIONS_INIT;
  		status_entry_counts counts;
  		static const char *paths[] = {
  			"a/.gitignore",
  			"a/ignoreme",
  			"b/.gitignore",
  			"b/ignoreme",
  		};
  		static const unsigned int statuses[] = {
  			GIT_STATUS_WT_NEW,
  			GIT_STATUS_IGNORED,
  			GIT_STATUS_WT_NEW,
  			GIT_STATUS_IGNORED,
  		};
  
  		memset(&counts, 0x0, sizeof(status_entry_counts));
  		counts.expected_entry_count = 4;
  		counts.expected_paths = paths;
  		counts.expected_statuses = statuses;
  
  		opts.flags = GIT_STATUS_OPT_DEFAULTS;
  
  		cl_git_pass(git_status_foreach_ext(
  			g_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);
  	}
  }
  
  

Download