rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clar/repo/setters.c

@@ -0,0 +1,80 @@
+#include "clar_libgit2.h"
+#include "buffer.h"
+#include "posix.h"
+#include "util.h"
+
+static git_repository *repo;
+
+void test_repo_setters__initialize(void)
+{
+	cl_fixture_sandbox("testrepo.git");
+	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+	cl_must_pass(p_mkdir("new_workdir", 0777));
+}
+
+void test_repo_setters__cleanup(void)
+{
+	git_repository_free(repo);
+	cl_fixture_cleanup("testrepo.git");
+	cl_must_pass(p_rmdir("new_workdir"));
+}
+
+void test_repo_setters__setting_a_workdir_turns_a_bare_repository_into_a_standard_one(void)
+{
+	cl_assert(git_repository_is_bare(repo) == 1);
+
+	cl_assert(git_repository_workdir(repo) == NULL);
+	cl_git_pass(git_repository_set_workdir(repo, "./new_workdir"));
+
+	cl_assert(git_repository_workdir(repo) != NULL);
+	cl_assert(git_repository_is_bare(repo) == 0);
+}
+
+void test_repo_setters__setting_a_workdir_prettifies_its_path(void)
+{
+	cl_git_pass(git_repository_set_workdir(repo, "./new_workdir"));
+
+	cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0);
+}
+
+void test_repo_setters__setting_a_new_index_on_a_repo_which_has_already_loaded_one_properly_honors_the_refcount(void)
+{
+	git_index *new_index;
+
+	cl_git_pass(git_index_open(&new_index, "./my-index"));
+	cl_assert(((git_refcount *)new_index)->refcount == 1);
+
+	git_repository_set_index(repo, new_index);
+	cl_assert(((git_refcount *)new_index)->refcount == 2);
+
+	git_repository_free(repo);
+	cl_assert(((git_refcount *)new_index)->refcount == 1);
+
+	git_index_free(new_index);
+
+	/* 
+	 * Ensure the cleanup method won't try to free the repo as it's already been taken care of
+	 */
+	repo = NULL;
+}
+
+void test_repo_setters__setting_a_new_odb_on_a_repo_which_already_loaded_one_properly_honors_the_refcount(void)
+{
+	git_odb *new_odb;
+
+	cl_git_pass(git_odb_open(&new_odb, "./testrepo.git/objects"));
+	cl_assert(((git_refcount *)new_odb)->refcount == 1);
+
+	git_repository_set_odb(repo, new_odb);
+	cl_assert(((git_refcount *)new_odb)->refcount == 2);
+
+	git_repository_free(repo);
+	cl_assert(((git_refcount *)new_odb)->refcount == 1);
+
+	git_odb_free(new_odb);
+
+	/* 
+	 * Ensure the cleanup method won't try to free the repo as it's already been taken care of
+	 */
+	repo = NULL;
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/reset/mixed.c

@@ -0,0 +1,47 @@
+#include "clar_libgit2.h"
+#include "posix.h"
+#include "reset_helpers.h"
+#include "path.h"
+
+static git_repository *repo;
+static git_object *target;
+
+void test_reset_mixed__initialize(void)
+{
+	repo = cl_git_sandbox_init("attr");
+	target = NULL;
+}
+
+void test_reset_mixed__cleanup(void)
+{
+	git_object_free(target);
+	cl_git_sandbox_cleanup();
+}
+
+void test_reset_mixed__cannot_reset_in_a_bare_repository(void)
+{
+	git_repository *bare;
+
+	cl_git_pass(git_repository_open(&bare, cl_fixture("testrepo.git")));
+	cl_assert(git_repository_is_bare(bare) == true);
+
+	retrieve_target_from_oid(&target, bare, KNOWN_COMMIT_IN_BARE_REPO);
+
+	cl_git_fail(git_reset(bare, target, GIT_RESET_MIXED));
+
+	git_repository_free(bare);
+}
+
+void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void)
+{
+	unsigned int status;
+
+	cl_git_pass(git_status_file(&status, repo, "macro_bad"));
+	cl_assert(status == GIT_STATUS_CURRENT);
+	retrieve_target_from_oid(&target, repo, "605812ab7fe421fdd325a935d35cb06a9234a7d7");
+
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
+
+	cl_git_pass(git_status_file(&status, repo, "macro_bad"));
+	cl_assert(status == GIT_STATUS_WT_NEW);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/reset/reset_helpers.c

@@ -0,0 +1,10 @@
+#include "clar_libgit2.h"
+#include "reset_helpers.h"
+
+void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha)
+{
+	git_oid oid;
+
+	cl_git_pass(git_oid_fromstr(&oid, sha));
+	cl_git_pass(git_object_lookup(object_out, repo, &oid, GIT_OBJ_ANY));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/reset/reset_helpers.h

@@ -0,0 +1,6 @@
+#include "common.h"
+
+#define KNOWN_COMMIT_IN_BARE_REPO "e90810b8df3e80c413d903f631643c716887138d"
+#define KNOWN_COMMIT_IN_ATTR_REPO "217878ab49e1314388ea2e32dc6fdb58a1b969e0"
+
+extern void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha);

data/ext/rugged/vendor/libgit2-dist/tests-clar/reset/soft.c

@@ -0,0 +1,102 @@
+#include "clar_libgit2.h"
+#include "reset_helpers.h"
+
+static git_repository *repo;
+static git_object *target;
+
+void test_reset_soft__initialize(void)
+{
+	repo = cl_git_sandbox_init("testrepo.git");
+}
+
+void test_reset_soft__cleanup(void)
+{
+	git_object_free(target);
+	cl_git_sandbox_cleanup();
+}
+
+static void assert_reset_soft(bool should_be_detached)
+{
+	git_oid oid;
+
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+	cl_git_fail(git_oid_streq(&oid, KNOWN_COMMIT_IN_BARE_REPO));
+
+	retrieve_target_from_oid(&target, repo, KNOWN_COMMIT_IN_BARE_REPO);
+
+	cl_assert(git_repository_head_detached(repo) == should_be_detached);
+
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+
+	cl_assert(git_repository_head_detached(repo) == should_be_detached);
+
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+	cl_git_pass(git_oid_streq(&oid, KNOWN_COMMIT_IN_BARE_REPO));
+}
+
+void test_reset_soft__can_reset_the_non_detached_Head_to_the_specified_commit(void)
+{
+	assert_reset_soft(false);
+}
+
+static void detach_head(void)
+{
+	git_reference *head;
+	git_oid oid;
+
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+
+	cl_git_pass(git_reference_create_oid(&head, repo, "HEAD", &oid, true));
+	git_reference_free(head);
+}
+
+void test_reset_soft__can_reset_the_detached_Head_to_the_specified_commit(void)
+{
+	detach_head();
+
+	assert_reset_soft(true);
+}
+
+void test_reset_soft__resetting_to_the_commit_pointed_at_by_the_Head_does_not_change_the_target_of_the_Head(void)
+{
+	git_oid oid;
+	char raw_head_oid[GIT_OID_HEXSZ + 1];
+
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+	git_oid_fmt(raw_head_oid, &oid);
+	raw_head_oid[GIT_OID_HEXSZ] = '\0';
+
+	retrieve_target_from_oid(&target, repo, raw_head_oid);
+
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+	cl_git_pass(git_oid_streq(&oid, raw_head_oid));
+}
+
+void test_reset_soft__resetting_to_a_tag_sets_the_Head_to_the_peeled_commit(void)
+{
+	git_oid oid;
+
+	/* b25fa35 is a tag, pointing to another tag which points to commit e90810b */
+	retrieve_target_from_oid(&target, repo, "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
+
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+
+	cl_assert(git_repository_head_detached(repo) == false);
+	cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD"));
+	cl_git_pass(git_oid_streq(&oid, KNOWN_COMMIT_IN_BARE_REPO));
+}
+
+void test_reset_soft__cannot_reset_to_a_tag_not_pointing_at_a_commit(void)
+{
+	/* 53fc32d is the tree of commit e90810b */
+	retrieve_target_from_oid(&target, repo, "53fc32d17276939fc79ed05badaef2db09990016");
+
+	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
+	git_object_free(target);
+
+	/* 521d87c is an annotated tag pointing to a blob */
+	retrieve_target_from_oid(&target, repo, "521d87c1ec3aef9824daf6d96cc0ae3710766d91");
+	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
+}

data/ext/rugged/vendor/libgit2-dist/{tests/t05-revwalk.c → tests-clar/revwalk/basic.c}

@@ -1,29 +1,4 @@
-/*
- * This file is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2,
- * as published by the Free Software Foundation.
- *
- * In addition to the permissions in the GNU General Public License,
- * the authors give you unlimited permission to link the compiled
- * version of this file into combinations with other programs,
- * and to distribute those combinations without any restriction
- * coming from the use of this file.  (The General Public License
- * restrictions do apply in other respects; for example, they cover
- * modification of the file, and distribution when not linked into
- * a combined executable.)
- *
- * This file is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- */
-#include "test_lib.h"
-#include "test_helpers.h"
+#include "clar_libgit2.h"
 
 /*
 	$ git log --oneline --graph --decorate
@@ -98,7 +73,7 @@ static int test_walk(git_revwalk *walk, const git_oid *root,
 
 	i = 0;
 
-	while (git_revwalk_next(&oid, walk) == GIT_SUCCESS) {
+	while (git_revwalk_next(&oid, walk) == 0) {
 		result_array[i++] = get_commit_index(&oid);
 		/*{
 			char str[41];
@@ -111,30 +86,96 @@ static int test_walk(git_revwalk *walk, const git_oid *root,
 	for (i = 0; i < results_count; ++i)
 		if (memcmp(possible_results[i],
 				result_array, result_bytes) == 0)
-			return GIT_SUCCESS;
+			return 0;
 
 	return GIT_ERROR;
 }
 
-BEGIN_TEST(walk0, "do a simple walk on a repo with different sorting modes")
-	git_oid id;
-	git_repository *repo;
-	git_revwalk *walk;
+static git_repository *_repo;
+static git_revwalk *_walk;
 
-	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
-	must_pass(git_revwalk_new(&walk, repo));
+void test_revwalk_basic__initialize(void)
+{
+	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
+	cl_git_pass(git_revwalk_new(&_walk, _repo));
+}
+
+void test_revwalk_basic__cleanup(void)
+{
+	git_revwalk_free(_walk);
+	git_repository_free(_repo);
+}
+
+void test_revwalk_basic__sorting_modes(void)
+{
+	git_oid id;
 
 	git_oid_fromstr(&id, commit_head);
 
-	must_pass(test_walk(walk, &id, GIT_SORT_TIME, commit_sorting_time, 1));
-	must_pass(test_walk(walk, &id, GIT_SORT_TOPOLOGICAL, commit_sorting_topo, 2));
-	must_pass(test_walk(walk, &id, GIT_SORT_TIME | GIT_SORT_REVERSE, commit_sorting_time_reverse, 1));
-	must_pass(test_walk(walk, &id, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE, commit_sorting_topo_reverse, 2));
+	cl_git_pass(test_walk(_walk, &id, GIT_SORT_TIME, commit_sorting_time, 1));
+	cl_git_pass(test_walk(_walk, &id, GIT_SORT_TOPOLOGICAL, commit_sorting_topo, 2));
+	cl_git_pass(test_walk(_walk, &id, GIT_SORT_TIME | GIT_SORT_REVERSE, commit_sorting_time_reverse, 1));
+	cl_git_pass(test_walk(_walk, &id, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE, commit_sorting_topo_reverse, 2));
+}
 
-	git_revwalk_free(walk);
-	git_repository_free(repo);
-END_TEST
+void test_revwalk_basic__glob_heads(void)
+{
+	int i = 0;
+	git_oid oid;
+
+	cl_git_pass(git_revwalk_push_glob(_walk, "heads"));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git log --branches --oneline | wc -l => 13 */
+	cl_assert(i == 13);
+}
+
+void test_revwalk_basic__push_head(void)
+{
+	int i = 0;
+	git_oid oid;
 
-BEGIN_SUITE(revwalk)
-	ADD_TEST(walk0);
-END_SUITE
+	cl_git_pass(git_revwalk_push_head(_walk));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git log HEAD --oneline | wc -l => 7 */
+	cl_assert(i == 7);
+}
+
+void test_revwalk_basic__push_head_hide_ref(void)
+{
+	int i = 0;
+	git_oid oid;
+
+	cl_git_pass(git_revwalk_push_head(_walk));
+	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git log HEAD --oneline --not refs/heads/packed-test | wc -l => 4 */
+	cl_assert(i == 4);
+}
+
+void test_revwalk_basic__push_head_hide_ref_nobase(void)
+{
+	int i = 0;
+	git_oid oid;
+
+	cl_git_pass(git_revwalk_push_head(_walk));
+	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed"));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git log HEAD --oneline --not refs/heads/packed | wc -l => 7 */
+	cl_assert(i == 7);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/revwalk/mergebase.c

@@ -0,0 +1,148 @@
+#include "clar_libgit2.h"
+
+static git_repository *_repo;
+
+void test_revwalk_mergebase__initialize(void)
+{
+	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
+}
+
+void test_revwalk_mergebase__cleanup(void)
+{
+	git_repository_free(_repo);
+}
+
+void test_revwalk_mergebase__single1(void)
+{
+	git_oid result, one, two, expected;
+
+	git_oid_fromstr(&one, "c47800c7266a2be04c571c04d5a6614691ea99bd ");
+	git_oid_fromstr(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	git_oid_fromstr(&expected, "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+
+	cl_git_pass(git_merge_base(&result, _repo, &one, &two));
+	cl_assert(git_oid_cmp(&result, &expected) == 0);
+}
+
+void test_revwalk_mergebase__single2(void)
+{
+	git_oid result, one, two, expected;
+
+	git_oid_fromstr(&one, "763d71aadf09a7951596c9746c024e7eece7c7af");
+	git_oid_fromstr(&two, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	git_oid_fromstr(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd");
+
+	cl_git_pass(git_merge_base(&result, _repo, &one, &two));
+	cl_assert(git_oid_cmp(&result, &expected) == 0);
+}
+
+void test_revwalk_mergebase__merged_branch(void)
+{
+	git_oid result, one, two, expected;
+
+	git_oid_fromstr(&one, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	git_oid_fromstr(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a");
+	git_oid_fromstr(&expected, "9fd738e8f7967c078dceed8190330fc8648ee56a");
+
+	cl_git_pass(git_merge_base(&result, _repo, &one, &two));
+	cl_assert(git_oid_cmp(&result, &expected) == 0);
+
+	cl_git_pass(git_merge_base(&result, _repo, &two, &one));
+	cl_assert(git_oid_cmp(&result, &expected) == 0);
+}
+
+void test_revwalk_mergebase__no_common_ancestor_returns_ENOTFOUND(void)
+{
+	git_oid result, one, two, expected;
+	int error;
+
+	git_oid_fromstr(&one, "763d71aadf09a7951596c9746c024e7eece7c7af");
+	git_oid_fromstr(&two, "e90810b8df3e80c413d903f631643c716887138d");
+	git_oid_fromstr(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd");
+
+	error = git_merge_base(&result, _repo, &one, &two);
+	cl_git_fail(error);
+
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
+}
+
+/*
+ * $ git log --graph --all
+ * * commit 763d71aadf09a7951596c9746c024e7eece7c7af
+ * | Author: nulltoken <emeric.fermas@gmail.com>
+ * | Date:   Sun Oct 9 12:54:47 2011 +0200
+ * |
+ * |     Add some files into subdirectories
+ * |
+ * | * commit a65fedf39aefe402d3bb6e24df4d4f5fe4547750
+ * | | Author: Scott Chacon <schacon@gmail.com>
+ * | | Date:   Tue Aug 9 19:33:46 2011 -0700
+ * | |
+ * | *   commit be3563ae3f795b2b4353bcce3a527ad0a4f7f644
+ * | |\  Merge: 9fd738e c47800c
+ * | |/  Author: Scott Chacon <schacon@gmail.com>
+ * |/|   Date:   Tue May 25 11:58:27 2010 -0700
+ * | |
+ * | |       Merge branch 'br2'
+ * | |
+ * | | * commit e90810b8df3e80c413d903f631643c716887138d
+ * | | | Author: Vicent Marti <tanoku@gmail.com>
+ * | | | Date:   Thu Aug 5 18:42:20 2010 +0200
+ * | | |
+ * | | |     Test commit 2
+ * | | |
+ * | | * commit 6dcf9bf7541ee10456529833502442f385010c3d
+ * | |   Author: Vicent Marti <tanoku@gmail.com>
+ * | |   Date:   Thu Aug 5 18:41:33 2010 +0200
+ * | |
+ * | |       Test commit 1
+ * | |
+ * | | *   commit a4a7dce85cf63874e984719f4fdd239f5145052f
+ * | | |\  Merge: c47800c 9fd738e
+ * | |/ /  Author: Scott Chacon <schacon@gmail.com>
+ * |/| /   Date:   Tue May 25 12:00:23 2010 -0700
+ * | |/
+ * | |         Merge branch 'master' into br2
+ * | |
+ * | * commit 9fd738e8f7967c078dceed8190330fc8648ee56a
+ * | | Author: Scott Chacon <schacon@gmail.com>
+ * | | Date:   Mon May 24 10:19:19 2010 -0700
+ * | |
+ * | |     a fourth commit
+ * | |
+ * | * commit 4a202b346bb0fb0db7eff3cffeb3c70babbd2045
+ * | | Author: Scott Chacon <schacon@gmail.com>
+ * | | Date:   Mon May 24 10:19:04 2010 -0700
+ * | |
+ * | |     a third commit
+ * | |
+ * * | commit c47800c7266a2be04c571c04d5a6614691ea99bd
+ * |/  Author: Scott Chacon <schacon@gmail.com>
+ * |   Date:   Tue May 25 11:58:14 2010 -0700
+ * |
+ * |       branch commit one
+ * |
+ * * commit 5b5b025afb0b4c913b4c338a42934a3863bf3644
+ * | Author: Scott Chacon <schacon@gmail.com>
+ * | Date:   Tue May 11 13:38:42 2010 -0700
+ * |
+ * |     another commit
+ * |
+ * * commit 8496071c1b46c854b31185ea97743be6a8774479
+ *   Author: Scott Chacon <schacon@gmail.com>
+ *   Date:   Sat May 8 16:13:06 2010 -0700
+ * 
+ *       testing
+ * 
+ * * commit 41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9
+ * | Author: Scott Chacon <schacon@gmail.com>
+ * | Date:   Tue May 11 13:40:41 2010 -0700
+ * |
+ * |     packed commit two
+ * |
+ * * commit 5001298e0c09ad9c34e4249bc5801c75e9754fa5
+ *   Author: Scott Chacon <schacon@gmail.com>
+ *   Date:   Tue May 11 13:40:23 2010 -0700
+ * 
+ *       packed commit one
+ */

data/ext/rugged/vendor/libgit2-dist/tests-clar/status/ignore.c

@@ -0,0 +1,133 @@
+#include "clar_libgit2.h"
+#include "fileops.h"
+#include "git2/attr.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[] = {
+		/* patterns "sub" and "ign" from .gitignore */
+		{ "file", 0 },
+		{ "ign", 1 },
+		{ "sub", 1 },
+		{ "sub/file", 0 },
+		{ "sub/ign", 1 },
+		{ "sub/sub", 1 },
+		{ "sub/sub/file", 0 },
+		{ "sub/sub/ign", 1 },
+		{ "sub/sub/sub", 1 },
+		/* pattern "dir/" from .gitignore */
+		{ "dir", 1 },
+		{ "dir/", 1 },
+		{ "sub/dir", 1 },
+		{ "sub/dir/", 1 },
+		{ "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);
+}
+