thodg/libgit2/tests-clar/repo/iterator.c

• Show log

  Commit

• Hash : d85296ab
  Author :
  Date : 2013-03-14T13:50:54
  

  Fix valgrind issues (and mmap fallback for diff) This fixes a number of issues identified by valgrind - mostly missed free calls. Inside valgrind, mmap() may fail which causes some of the diff tests to fail. This adds a fallback code path to diff_output.c:get_workdir_content() where is the mmap() fails the code will now try to read the file data directly into allocated memory (which is what it would do if the data needed to be filtered anyhow).

Download

• tests-clar/repo/iterator.c

• #include "clar_libgit2.h"
  #include "iterator.h"
  #include "repository.h"
  #include "fileops.h"
  #include <stdarg.h>
  
  static git_repository *g_repo;
  
  void test_repo_iterator__initialize(void)
  {
  }
  
  void test_repo_iterator__cleanup(void)
  {
  	cl_git_sandbox_cleanup();
  	g_repo = NULL;
  }
  
  static void expect_iterator_items(
  	git_iterator *i,
  	int expected_flat,
  	const char **expected_flat_paths,
  	int expected_total,
  	const char **expected_total_paths)
  {
  	const git_index_entry *entry;
  	int count, error;
  	int no_trees = !(git_iterator_flags(i) & GIT_ITERATOR_INCLUDE_TREES);
  	bool v = false;
  
  	if (expected_flat < 0) { v = true; expected_flat = -expected_flat; }
  	if (expected_total < 0) { v = true; expected_total = -expected_total; }
  
  	count = 0;
  	cl_git_pass(git_iterator_current(&entry, i));
  
  	if (v) fprintf(stderr, "== %s ==\n", no_trees ? "notrees" : "trees");
  
  	while (entry != NULL) {
  		if (v) fprintf(stderr, "  %s %07o\n", entry->path, (int)entry->mode);
  
  		if (no_trees)
  			cl_assert(entry->mode != GIT_FILEMODE_TREE);
  
  		if (expected_flat_paths) {
  			const char *expect_path = expected_flat_paths[count];
  			size_t expect_len = strlen(expect_path);
  
  			cl_assert_equal_s(expect_path, entry->path);
  
  			if (expect_path[expect_len - 1] == '/')
  				cl_assert_equal_i(GIT_FILEMODE_TREE, entry->mode);
  			else
  				cl_assert(entry->mode != GIT_FILEMODE_TREE);
  		}
  
  		cl_git_pass(git_iterator_advance(&entry, i));
  
  		if (++count > expected_flat)
  			break;
  	}
  
  	cl_assert_equal_i(expected_flat, count);
  
  	cl_git_pass(git_iterator_reset(i, NULL, NULL));
  
  	count = 0;
  	cl_git_pass(git_iterator_current(&entry, i));
  
  	if (v) fprintf(stderr, "-- %s --\n", no_trees ? "notrees" : "trees");
  
  	while (entry != NULL) {
  		if (v) fprintf(stderr, "  %s %07o\n", entry->path, (int)entry->mode);
  
  		if (no_trees)
  			cl_assert(entry->mode != GIT_FILEMODE_TREE);
  
  		if (expected_total_paths) {
  			const char *expect_path = expected_total_paths[count];
  			size_t expect_len = strlen(expect_path);
  
  			cl_assert_equal_s(expect_path, entry->path);
  
  			if (expect_path[expect_len - 1] == '/')
  				cl_assert_equal_i(GIT_FILEMODE_TREE, entry->mode);
  			else
  				cl_assert(entry->mode != GIT_FILEMODE_TREE);
  		}
  
  		if (entry->mode == GIT_FILEMODE_TREE) {
  			error = git_iterator_advance_into(&entry, i);
  
  			/* could return NOTFOUND if directory is empty */
  			cl_assert(!error || error == GIT_ENOTFOUND);
  
  			if (error == GIT_ENOTFOUND)
  				cl_git_pass(git_iterator_advance(&entry, i));
  		} else
  			cl_git_pass(git_iterator_advance(&entry, i));
  
  		if (++count > expected_total)
  			break;
  	}
  
  	cl_assert_equal_i(expected_total, count);
  }
  
  /* Index contents (including pseudotrees):
   *
   * 0: a     5: F     10: k/      16: L/
   * 1: B     6: g     11: k/1     17: L/1
   * 2: c     7: H     12: k/a     18: L/a
   * 3: D     8: i     13: k/B     19: L/B
   * 4: e     9: J     14: k/c     20: L/c
   *                   15: k/D     21: L/D
   *
   * 0: B     5: L/    11: a       16: k/
   * 1: D     6: L/1   12: c       17: k/1
   * 2: F     7: L/B   13: e       18: k/B
   * 3: H     8: L/D   14: g       19: k/D
   * 4: J     9: L/a   15: i       20: k/a
   *         10: L/c               21: k/c
   */
  
  void test_repo_iterator__index(void)
  {
  	git_iterator *i;
  	git_index *index;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_repository_index(&index, g_repo));
  
  	/* autoexpand with no tree entries for index */
  	cl_git_pass(git_iterator_for_index(&i, index, 0, NULL, NULL));
  	expect_iterator_items(i, 20, NULL, 20, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 22, NULL, 22, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
  	expect_iterator_items(i, 12, NULL, 22, NULL);
  	git_iterator_free(i);
  
  	git_index_free(index);
  }
  
  void test_repo_iterator__index_icase(void)
  {
  	git_iterator *i;
  	git_index *index;
  	unsigned int caps;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_repository_index(&index, g_repo));
  	caps = git_index_caps(index);
  
  	/* force case sensitivity */
  	cl_git_pass(git_index_set_caps(index, caps & ~GIT_INDEXCAP_IGNORE_CASE));
  
  	/* autoexpand with no tree entries over range */
  	cl_git_pass(git_iterator_for_index(&i, index, 0, "c", "k/D"));
  	expect_iterator_items(i, 7, NULL, 7, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_index(&i, index, 0, "k", "k/Z"));
  	expect_iterator_items(i, 3, NULL, 3, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 8, NULL, 8, NULL);
  	git_iterator_free(i);
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 4, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 5, NULL, 8, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	/* force case insensitivity */
  	cl_git_pass(git_index_set_caps(index, caps | GIT_INDEXCAP_IGNORE_CASE));
  
  	/* autoexpand with no tree entries over range */
  	cl_git_pass(git_iterator_for_index(&i, index, 0, "c", "k/D"));
  	expect_iterator_items(i, 13, NULL, 13, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_index(&i, index, 0, "k", "k/Z"));
  	expect_iterator_items(i, 5, NULL, 5, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 14, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 6, NULL, 6, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 9, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_index(
  		&i, index, GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 6, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_index_set_caps(index, caps));
  	git_index_free(index);
  }
  
  void test_repo_iterator__tree(void)
  {
  	git_iterator *i;
  	git_tree *head;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_repository_head_tree(&head, g_repo));
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_tree(&i, head, 0, NULL, NULL));
  	expect_iterator_items(i, 20, NULL, 20, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 22, NULL, 22, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
  	expect_iterator_items(i, 12, NULL, 22, NULL);
  	git_iterator_free(i);
  
  	git_tree_free(head);
  }
  
  void test_repo_iterator__tree_icase(void)
  {
  	git_iterator *i;
  	git_tree *head;
  	git_iterator_flag_t flag;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_repository_head_tree(&head, g_repo));
  
  	flag = GIT_ITERATOR_DONT_IGNORE_CASE;
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_tree(&i, head, flag, "c", "k/D"));
  	expect_iterator_items(i, 7, NULL, 7, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(&i, head, flag, "k", "k/Z"));
  	expect_iterator_items(i, 3, NULL, 3, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 8, NULL, 8, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 4, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 5, NULL, 8, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	flag = GIT_ITERATOR_IGNORE_CASE;
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_tree(&i, head, flag, "c", "k/D"));
  	expect_iterator_items(i, 13, NULL, 13, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(&i, head, flag, "k", "k/Z"));
  	expect_iterator_items(i, 5, NULL, 5, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 14, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 6, NULL, 6, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 9, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 6, NULL);
  	git_iterator_free(i);
  
  	git_tree_free(head);
  }
  
  void test_repo_iterator__tree_more(void)
  {
  	git_iterator *i;
  	git_tree *head;
  	static const char *expect_basic[] = {
  		"current_file",
  		"file_deleted",
  		"modified_file",
  		"staged_changes",
  		"staged_changes_file_deleted",
  		"staged_changes_modified_file",
  		"staged_delete_file_deleted",
  		"staged_delete_modified_file",
  		"subdir.txt",
  		"subdir/current_file",
  		"subdir/deleted_file",
  		"subdir/modified_file",
  		NULL,
  	};
  	static const char *expect_trees[] = {
  		"current_file",
  		"file_deleted",
  		"modified_file",
  		"staged_changes",
  		"staged_changes_file_deleted",
  		"staged_changes_modified_file",
  		"staged_delete_file_deleted",
  		"staged_delete_modified_file",
  		"subdir.txt",
  		"subdir/",
  		"subdir/current_file",
  		"subdir/deleted_file",
  		"subdir/modified_file",
  		NULL,
  	};
  	static const char *expect_noauto[] = {
  		"current_file",
  		"file_deleted",
  		"modified_file",
  		"staged_changes",
  		"staged_changes_file_deleted",
  		"staged_changes_modified_file",
  		"staged_delete_file_deleted",
  		"staged_delete_modified_file",
  		"subdir.txt",
  		"subdir/",
  		NULL
  	};
  
  	g_repo = cl_git_sandbox_init("status");
  
  	cl_git_pass(git_repository_head_tree(&head, g_repo));
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_tree(&i, head, 0, NULL, NULL));
  	expect_iterator_items(i, 12, expect_basic, 12, expect_basic);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 13, expect_trees, 13, expect_trees);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_tree(
  		&i, head, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
  	expect_iterator_items(i, 10, expect_noauto, 13, expect_trees);
  	git_iterator_free(i);
  
  	git_tree_free(head);
  }
  
  /* "b=name,t=name", blob_id, tree_id */
  static void build_test_tree(
  	git_oid *out, git_repository *repo, const char *fmt, ...)
  {
  	git_oid *id;
  	git_treebuilder *builder;
  	const char *scan = fmt, *next;
  	char type, delimiter;
  	git_filemode_t mode;
  	git_buf name = GIT_BUF_INIT;
  	va_list arglist;
  
  	cl_git_pass(git_treebuilder_create(&builder, NULL)); /* start builder */
  
  	va_start(arglist, fmt);
  	while (*scan) {
  		switch (type = *scan++) {
  		case 't': case 'T': mode = GIT_FILEMODE_TREE; break;
  		case 'b': case 'B': mode = GIT_FILEMODE_BLOB; break;
  		default:
  			cl_assert(type == 't' || type == 'T' || type == 'b' || type == 'B');
  		}
  
  		delimiter = *scan++; /* read and skip delimiter */
  		for (next = scan; *next && *next != delimiter; ++next)
  			/* seek end */;
  		cl_git_pass(git_buf_set(&name, scan, (size_t)(next - scan)));
  		for (scan = next; *scan && (*scan == delimiter || *scan == ','); ++scan)
  			/* skip delimiter and optional comma */;
  
  		id = va_arg(arglist, git_oid *);
  
  		cl_git_pass(git_treebuilder_insert(NULL, builder, name.ptr, id, mode));
  	}
  	va_end(arglist);
  
  	cl_git_pass(git_treebuilder_write(out, repo, builder));
  
  	git_treebuilder_free(builder);
  	git_buf_free(&name);
  }
  
  void test_repo_iterator__tree_case_conflicts_0(void)
  {
  	const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6";
  	git_tree *tree;
  	git_oid blob_id, biga_id, littlea_id, tree_id;
  	git_iterator *i;
  	const char *expect_cs[] = {
  		"A/1.file", "A/3.file", "a/2.file", "a/4.file" };
  	const char *expect_ci[] = {
  		"A/1.file", "a/2.file", "A/3.file", "a/4.file" };
  	const char *expect_cs_trees[] = {
  		"A/", "A/1.file", "A/3.file", "a/", "a/2.file", "a/4.file" };
  	const char *expect_ci_trees[] = {
  		"A/", "A/1.file", "a/2.file", "A/3.file", "a/4.file" };
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */
  
  	/* create tree with: A/1.file, A/3.file, a/2.file, a/4.file */
  	build_test_tree(
  		&biga_id, g_repo, "b|1.file|,b|3.file|", &blob_id, &blob_id);
  	build_test_tree(
  		&littlea_id, g_repo, "b|2.file|,b|4.file|", &blob_id, &blob_id);
  	build_test_tree(
  		&tree_id, g_repo, "t|A|,t|a|", &biga_id, &littlea_id);
  
  	cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 4, expect_cs, 4, expect_cs);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 4, expect_ci, 4, expect_ci);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE |
  		GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 6, expect_cs_trees, 6, expect_cs_trees);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE |
  		GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 5, expect_ci_trees, 5, expect_ci_trees);
  	git_iterator_free(i);
  
  	git_tree_free(tree);
  }
  
  void test_repo_iterator__tree_case_conflicts_1(void)
  {
  	const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6";
  	git_tree *tree;
  	git_oid blob_id, Ab_id, biga_id, littlea_id, tree_id;
  	git_iterator *i;
  	const char *expect_cs[] = {
  		"A/a", "A/b/1", "A/c", "a/C", "a/a", "a/b" };
  	const char *expect_ci[] = {
  		"A/a", "a/b", "A/b/1", "A/c" };
  	const char *expect_cs_trees[] = {
  		"A/", "A/a", "A/b/", "A/b/1", "A/c", "a/", "a/C", "a/a", "a/b" };
  	const char *expect_ci_trees[] = {
  		"A/", "A/a", "a/b", "A/b/", "A/b/1", "A/c" };
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */
  
  	/* create: A/a A/b/1 A/c a/a a/b a/C */
  	build_test_tree(&Ab_id, g_repo, "b|1|", &blob_id);
  	build_test_tree(
  		&biga_id, g_repo, "b|a|,t|b|,b|c|", &blob_id, &Ab_id, &blob_id);
  	build_test_tree(
  		&littlea_id, g_repo, "b|a|,b|b|,b|C|", &blob_id, &blob_id, &blob_id);
  	build_test_tree(
  		&tree_id, g_repo, "t|A|,t|a|", &biga_id, &littlea_id);
  
  	cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 6, expect_cs, 6, expect_cs);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 4, expect_ci, 4, expect_ci);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE |
  		GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 9, expect_cs_trees, 9, expect_cs_trees);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE |
  		GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 6, expect_ci_trees, 6, expect_ci_trees);
  	git_iterator_free(i);
  
  	git_tree_free(tree);
  }
  
  void test_repo_iterator__tree_case_conflicts_2(void)
  {
  	const char *blob_sha = "d44e18fb93b7107b5cd1b95d601591d77869a1b6";
  	git_tree *tree;
  	git_oid blob_id, d1, d2, c1, c2, b1, b2, a1, a2, tree_id;
  	git_iterator *i;
  	const char *expect_cs[] = {
  		"A/B/C/D/16", "A/B/C/D/foo", "A/B/C/d/15",  "A/B/C/d/FOO",
  		"A/B/c/D/14", "A/B/c/D/foo", "A/B/c/d/13",  "A/B/c/d/FOO",
  		"A/b/C/D/12", "A/b/C/D/foo", "A/b/C/d/11",  "A/b/C/d/FOO",
  		"A/b/c/D/10", "A/b/c/D/foo", "A/b/c/d/09",  "A/b/c/d/FOO",
  		"a/B/C/D/08", "a/B/C/D/foo", "a/B/C/d/07", "a/B/C/d/FOO",
  		"a/B/c/D/06", "a/B/c/D/foo", "a/B/c/d/05", "a/B/c/d/FOO",
  		"a/b/C/D/04", "a/b/C/D/foo", "a/b/C/d/03", "a/b/C/d/FOO",
  		"a/b/c/D/02", "a/b/c/D/foo", "a/b/c/d/01", "a/b/c/d/FOO", };
  	const char *expect_ci[] = {
  		"a/b/c/d/01", "a/b/c/D/02", "a/b/C/d/03", "a/b/C/D/04",
  		"a/B/c/d/05", "a/B/c/D/06", "a/B/C/d/07", "a/B/C/D/08",
  		"A/b/c/d/09", "A/b/c/D/10", "A/b/C/d/11", "A/b/C/D/12",
  		"A/B/c/d/13", "A/B/c/D/14", "A/B/C/d/15", "A/B/C/D/16",
  		"A/B/C/D/foo", };
  	const char *expect_ci_trees[] = {
  		"A/", "A/B/", "A/B/C/", "A/B/C/D/",
  		"a/b/c/d/01", "a/b/c/D/02", "a/b/C/d/03", "a/b/C/D/04",
  		"a/B/c/d/05", "a/B/c/D/06", "a/B/C/d/07", "a/B/C/D/08",
  		"A/b/c/d/09", "A/b/c/D/10", "A/b/C/d/11", "A/b/C/D/12",
  		"A/B/c/d/13", "A/B/c/D/14", "A/B/C/d/15", "A/B/C/D/16",
  		"A/B/C/D/foo", };
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	cl_git_pass(git_oid_fromstr(&blob_id, blob_sha)); /* lookup blob */
  
  	build_test_tree(&d1, g_repo, "b|16|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|15|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&d1, g_repo, "b|14|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|13|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&b1, g_repo, "t|C|,t|c|", &c1, &c2);
  
  	build_test_tree(&d1, g_repo, "b|12|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|11|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&d1, g_repo, "b|10|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|09|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&b2, g_repo, "t|C|,t|c|", &c1, &c2);
  
  	build_test_tree(&a1, g_repo, "t|B|,t|b|", &b1, &b2);
  
  	build_test_tree(&d1, g_repo, "b|08|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|07|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&d1, g_repo, "b|06|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|05|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&b1, g_repo, "t|C|,t|c|", &c1, &c2);
  
  	build_test_tree(&d1, g_repo, "b|04|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|03|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c1, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&d1, g_repo, "b|02|,b|foo|", &blob_id, &blob_id);
  	build_test_tree(&d2, g_repo, "b|01|,b|FOO|", &blob_id, &blob_id);
  	build_test_tree(&c2, g_repo, "t|D|,t|d|", &d1, &d2);
  	build_test_tree(&b2, g_repo, "t|C|,t|c|", &c1, &c2);
  
  	build_test_tree(&a2, g_repo, "t|B|,t|b|", &b1, &b2);
  
  	build_test_tree(&tree_id, g_repo, "t/A/,t/a/", &a1, &a2);
  
  	cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 32, expect_cs, 32, expect_cs);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE, NULL, NULL));
  	expect_iterator_items(i, 17, expect_ci, 17, expect_ci);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_tree(
  		&i, tree, GIT_ITERATOR_IGNORE_CASE |
  		GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 21, expect_ci_trees, 21, expect_ci_trees);
  	git_iterator_free(i);
  
  	git_tree_free(tree);
  }
  
  void test_repo_iterator__workdir(void)
  {
  	git_iterator *i;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_workdir(&i, g_repo, 0, NULL, NULL));
  	expect_iterator_items(i, 20, NULL, 20, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(i, 22, NULL, 22, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
  	expect_iterator_items(i, 12, NULL, 22, NULL);
  	git_iterator_free(i);
  }
  
  void test_repo_iterator__workdir_icase(void)
  {
  	git_iterator *i;
  	git_iterator_flag_t flag;
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	flag = GIT_ITERATOR_DONT_IGNORE_CASE;
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "c", "k/D"));
  	expect_iterator_items(i, 7, NULL, 7, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "k", "k/Z"));
  	expect_iterator_items(i, 3, NULL, 3, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 8, NULL, 8, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 4, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 5, NULL, 8, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 4, NULL);
  	git_iterator_free(i);
  
  	flag = GIT_ITERATOR_IGNORE_CASE;
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "c", "k/D"));
  	expect_iterator_items(i, 13, NULL, 13, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(&i, g_repo, flag, "k", "k/Z"));
  	expect_iterator_items(i, 5, NULL, 5, NULL);
  	git_iterator_free(i);
  
  	/* auto expand with tree entries */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "c", "k/D"));
  	expect_iterator_items(i, 14, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_INCLUDE_TREES, "k", "k/Z"));
  	expect_iterator_items(i, 6, NULL, 6, NULL);
  	git_iterator_free(i);
  
  	/* no auto expand (implies trees included) */
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "c", "k/D"));
  	expect_iterator_items(i, 9, NULL, 14, NULL);
  	git_iterator_free(i);
  
  	cl_git_pass(git_iterator_for_workdir(
  		&i, g_repo, flag | GIT_ITERATOR_DONT_AUTOEXPAND, "k", "k/Z"));
  	expect_iterator_items(i, 1, NULL, 6, NULL);
  	git_iterator_free(i);
  }
  
  void test_repo_iterator__workdir_depth(void)
  {
  	int i, j;
  	git_iterator *iter;
  	char buf[64];
  
  	g_repo = cl_git_sandbox_init("icase");
  
  	for (i = 0; i < 10; ++i) {
  		p_snprintf(buf, sizeof(buf), "icase/dir%02d", i);
  		cl_git_pass(git_futils_mkdir(buf, NULL, 0775, GIT_MKDIR_PATH));
  
  		if (i % 2 == 0) {
  			p_snprintf(buf, sizeof(buf), "icase/dir%02d/file", i);
  			cl_git_mkfile(buf, buf);
  		}
  
  		for (j = 0; j < 10; ++j) {
  			p_snprintf(buf, sizeof(buf), "icase/dir%02d/sub%02d", i, j);
  			cl_git_pass(git_futils_mkdir(buf, NULL, 0775, GIT_MKDIR_PATH));
  
  			if (j % 2 == 0) {
  				p_snprintf(
  					buf, sizeof(buf), "icase/dir%02d/sub%02d/file", i, j);
  				cl_git_mkfile(buf, buf);
  			}
  		}
  	}
  
  	for (i = 1; i < 3; ++i) {
  		for (j = 0; j < 50; ++j) {
  			p_snprintf(buf, sizeof(buf), "icase/dir%02d/sub01/moar%02d", i, j);
  			cl_git_pass(git_futils_mkdir(buf, NULL, 0775, GIT_MKDIR_PATH));
  
  			if (j % 2 == 0) {
  				p_snprintf(buf, sizeof(buf),
  					"icase/dir%02d/sub01/moar%02d/file", i, j);
  				cl_git_mkfile(buf, buf);
  			}
  		}
  	}
  
  	/* auto expand with no tree entries */
  	cl_git_pass(git_iterator_for_workdir(&iter, g_repo, 0, NULL, NULL));
  	expect_iterator_items(iter, 125, NULL, 125, NULL);
  	git_iterator_free(iter);
  
  	/* auto expand with tree entries (empty dirs silently skipped) */
  	cl_git_pass(git_iterator_for_workdir(
  		&iter, g_repo, GIT_ITERATOR_INCLUDE_TREES, NULL, NULL));
  	expect_iterator_items(iter, 337, NULL, 337, NULL);
  	git_iterator_free(iter);
  }
  

Download