rugged 0.1.2 → 0.16.0b1

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

@@ -0,0 +1,174 @@
+/*
+ * 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 "odb.h"
+#include "git2/odb_backend.h"
+#include "repository.h"
+
+#define EMPTY_BARE_REPOSITORY_FOLDER TEST_RESOURCES "/empty_bare.git/"
+
+#define DISCOVER_FOLDER TEMP_REPO_FOLDER "discover.git"
+
+#define SUB_REPOSITORY_FOLDER_NAME "sub_repo"
+#define SUB_REPOSITORY_FOLDER DISCOVER_FOLDER "/" SUB_REPOSITORY_FOLDER_NAME
+#define SUB_REPOSITORY_FOLDER_SUB SUB_REPOSITORY_FOLDER "/sub"
+#define SUB_REPOSITORY_FOLDER_SUB_SUB SUB_REPOSITORY_FOLDER_SUB "/subsub"
+#define SUB_REPOSITORY_FOLDER_SUB_SUB_SUB SUB_REPOSITORY_FOLDER_SUB_SUB "/subsubsub"
+
+#define REPOSITORY_ALTERNATE_FOLDER DISCOVER_FOLDER "/alternate_sub_repo"
+#define REPOSITORY_ALTERNATE_FOLDER_SUB REPOSITORY_ALTERNATE_FOLDER "/sub"
+#define REPOSITORY_ALTERNATE_FOLDER_SUB_SUB REPOSITORY_ALTERNATE_FOLDER_SUB "/subsub"
+#define REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB REPOSITORY_ALTERNATE_FOLDER_SUB_SUB "/subsubsub"
+
+#define ALTERNATE_MALFORMED_FOLDER1 DISCOVER_FOLDER "/alternate_malformed_repo1"
+#define ALTERNATE_MALFORMED_FOLDER2 DISCOVER_FOLDER "/alternate_malformed_repo2"
+#define ALTERNATE_MALFORMED_FOLDER3 DISCOVER_FOLDER "/alternate_malformed_repo3"
+#define ALTERNATE_NOT_FOUND_FOLDER DISCOVER_FOLDER "/alternate_not_found_repo"
+
+static int ensure_repository_discover(const char *start_path, const char *ceiling_dirs, const char *expected_path)
+{
+	int error;
+	char found_path[GIT_PATH_MAX];
+
+	error = git_repository_discover(found_path, sizeof(found_path), start_path, 0, ceiling_dirs);
+	//across_fs is always 0 as we can't automate the filesystem change tests
+
+	if (error < GIT_SUCCESS)
+		return error;
+
+	return strcmp(found_path, expected_path) ? GIT_ERROR : GIT_SUCCESS;
+}
+
+static int write_file(const char *path, const char *content)
+{
+	int error;
+	git_file file;
+
+	if (git_futils_exists(path) == GIT_SUCCESS) {
+		error = p_unlink(path);
+
+		if (error < GIT_SUCCESS)
+			return error;
+	}
+
+	file = git_futils_creat_withpath(path, 0777, 0666);
+	if (file < GIT_SUCCESS)
+		return file;
+
+	error = p_write(file, content, strlen(content) * sizeof(char));
+
+	p_close(file);
+
+	return error;
+}
+
+//no check is performed on ceiling_dirs length, so be sure it's long enough
+static int append_ceiling_dir(char *ceiling_dirs, const char *path)
+{
+	int len = strlen(ceiling_dirs);
+	int error;
+
+	error = git_path_prettify_dir(ceiling_dirs + len + (len ? 1 : 0), path, NULL);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to append ceiling directory.");
+
+	if (len)
+		ceiling_dirs[len] = GIT_PATH_LIST_SEPARATOR;
+
+	return GIT_SUCCESS;
+}
+
+BEGIN_TEST(discover0, "test discover")
+	git_repository *repo;
+	char ceiling_dirs[GIT_PATH_MAX * 2] = "";
+	char repository_path[GIT_PATH_MAX];
+	char sub_repository_path[GIT_PATH_MAX];
+	char found_path[GIT_PATH_MAX];
+	const mode_t mode = 0777;
+
+	git_futils_mkdir_r(DISCOVER_FOLDER, mode);
+	must_pass(append_ceiling_dir(ceiling_dirs, TEMP_REPO_FOLDER));
+
+	must_be_true(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs) == GIT_ENOTAREPO);
+
+	must_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1));
+	must_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
+	git_repository_free(repo);
+
+	must_pass(git_repository_init(&repo, SUB_REPOSITORY_FOLDER, 0));
+	must_pass(git_futils_mkdir_r(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, mode));
+	must_pass(git_repository_discover(sub_repository_path, sizeof(sub_repository_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
+
+	must_pass(git_futils_mkdir_r(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, mode));
+	must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, ceiling_dirs, sub_repository_path));
+
+	must_pass(git_futils_mkdir_r(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, mode));
+	must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER "/" DOT_GIT, "gitdir: ../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT));
+	must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB "/" DOT_GIT, "gitdir: ../../../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT));
+	must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB "/" DOT_GIT, "gitdir: ../../../../"));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path));
+
+	must_pass(git_futils_mkdir_r(ALTERNATE_MALFORMED_FOLDER1, mode));
+	must_pass(write_file(ALTERNATE_MALFORMED_FOLDER1 "/" DOT_GIT, "Anything but not gitdir:"));
+	must_pass(git_futils_mkdir_r(ALTERNATE_MALFORMED_FOLDER2, mode));
+	must_pass(write_file(ALTERNATE_MALFORMED_FOLDER2 "/" DOT_GIT, "gitdir:"));
+	must_pass(git_futils_mkdir_r(ALTERNATE_MALFORMED_FOLDER3, mode));
+	must_pass(write_file(ALTERNATE_MALFORMED_FOLDER3 "/" DOT_GIT, "gitdir: \n\n\n"));
+	must_pass(git_futils_mkdir_r(ALTERNATE_NOT_FOUND_FOLDER, mode));
+	must_pass(write_file(ALTERNATE_NOT_FOUND_FOLDER "/" DOT_GIT, "gitdir: a_repository_that_surely_does_not_exist"));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
+
+	must_pass(append_ceiling_dir(ceiling_dirs, SUB_REPOSITORY_FOLDER));
+	//this must pass as ceiling_directories cannot predent the current
+	//working directory to be checked
+	must_pass(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
+	must_fail(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
+
+	//.gitfile redirection should not be affected by ceiling directories
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path));
+	must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path));
+
+	must_pass(git_futils_rmdir_r(TEMP_REPO_FOLDER, 1));
+	git_repository_free(repo);
+END_TEST
+
+BEGIN_SUITE(repository)
+	ADD_TEST(discover0);
+END_SUITE
+

data/ext/rugged/vendor/libgit2-dist/tests/t13-threads.c

@@ -0,0 +1,41 @@
+/*
+ * 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 "cache.h"
+
+
+typedef struct {
+	git_cached_obj cached;
+	unsigned int __dummy;
+} ttest_obj;
+
+BEGIN_TEST(cache0, "run several threads polling the cache at the same time")
+
+END_TEST
+
+BEGIN_SUITE(threads)
+	ADD_TEST(cache0);
+END_SUITE

data/ext/rugged/vendor/libgit2-dist/tests/t17-bufs.c

@@ -0,0 +1,61 @@
+/*
+ * 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 <git2.h>
+#include "buffer.h"
+
+const char *test_string = "Have you seen that? Have you seeeen that??";
+
+BEGIN_TEST(buf0, "check that resizing works properly")
+	git_buf buf = GIT_BUF_INIT;
+	git_buf_puts(&buf, test_string);
+
+	must_be_true(git_buf_oom(&buf) == 0);
+	must_be_true(strcmp(git_buf_cstr(&buf), test_string) == 0);
+
+	git_buf_puts(&buf, test_string);
+	must_be_true(strlen(git_buf_cstr(&buf)) == strlen(test_string) * 2);
+	git_buf_free(&buf);
+END_TEST
+
+BEGIN_TEST(buf1, "check that printf works properly")
+	git_buf buf = GIT_BUF_INIT;
+
+	git_buf_printf(&buf, "%s %s %d ", "shoop", "da", 23);
+	must_be_true(git_buf_oom(&buf) == 0);
+	must_be_true(strcmp(git_buf_cstr(&buf), "shoop da 23 ") == 0);
+
+	git_buf_printf(&buf, "%s %d", "woop", 42);
+	must_be_true(git_buf_oom(&buf) == 0);
+	must_be_true(strcmp(git_buf_cstr(&buf), "shoop da 23 woop 42") == 0);
+	git_buf_free(&buf);
+END_TEST
+
+BEGIN_SUITE(buffers)
+	 ADD_TEST(buf0)
+	 ADD_TEST(buf1)
+END_SUITE

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

@@ -0,0 +1,448 @@
+/*
+ * 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 "fileops.h"
+#include "git2/status.h"
+
+static const char *test_blob_oid = "d4fa8600b4f37d7516bef4816ae2c64dbf029e3a";
+
+#define STATUS_WORKDIR_FOLDER TEST_RESOURCES "/status/"
+#define STATUS_REPOSITORY_TEMP_FOLDER TEMP_REPO_FOLDER ".gitted/"
+
+static int file_create(const char *filename, const char *content)
+{
+	int fd;
+
+	fd = p_creat(filename, 0666);
+	if (fd == 0)
+		return GIT_ERROR;
+	if (p_write(fd, content, strlen(content)) != 0)
+		return GIT_ERROR;
+	if (p_close(fd) != 0)
+		return GIT_ERROR;
+
+	return GIT_SUCCESS;
+}
+
+BEGIN_TEST(file0, "test retrieving OID from a file apart from the ODB")
+	git_oid expected_id, actual_id;
+	char filename[] = "new_file";
+
+	must_pass(file_create(filename, "new_file\n\0"));
+
+	must_pass(git_odb_hashfile(&actual_id, filename, GIT_OBJ_BLOB));
+
+	must_pass(git_oid_fromstr(&expected_id, test_blob_oid));
+	must_be_true(git_oid_cmp(&expected_id, &actual_id) == 0);
+
+	must_pass(p_unlink(filename));
+END_TEST
+
+static const char *entry_paths0[] = {
+	"file_deleted",
+	"modified_file",
+	"new_file",
+	"staged_changes",
+	"staged_changes_file_deleted",
+	"staged_changes_modified_file",
+	"staged_delete_file_deleted",
+	"staged_delete_modified_file",
+	"staged_new_file",
+	"staged_new_file_deleted_file",
+	"staged_new_file_modified_file",
+
+	"subdir/deleted_file",
+	"subdir/modified_file",
+	"subdir/new_file",
+};
+
+static const unsigned int entry_statuses0[] = {
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_MODIFIED,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_INDEX_MODIFIED | GIT_STATUS_WT_DELETED,
+	GIT_STATUS_INDEX_MODIFIED | GIT_STATUS_WT_MODIFIED,
+	GIT_STATUS_INDEX_DELETED,
+	GIT_STATUS_INDEX_DELETED | GIT_STATUS_WT_NEW,
+	GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_INDEX_NEW | GIT_STATUS_WT_DELETED,
+	GIT_STATUS_INDEX_NEW | GIT_STATUS_WT_MODIFIED,
+
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_MODIFIED,
+	GIT_STATUS_WT_NEW,
+};
+
+#define ENTRY_COUNT0 14
+
+struct status_entry_counts {
+	int wrong_status_flags_count;
+	int wrong_sorted_path;
+	int entry_count;
+	const unsigned int* expected_statuses;
+	const char** expected_paths;
+	int expected_entry_count;
+};
+
+static int status_cb(const char *path, unsigned int status_flags, void *payload)
+{
+	struct status_entry_counts *counts = (struct status_entry_counts *)payload;
+
+	if (counts->entry_count >= counts->expected_entry_count) {
+		counts->wrong_status_flags_count++;
+		goto exit;
+	}
+
+	if (strcmp(path, counts->expected_paths[counts->entry_count])) {
+		counts->wrong_sorted_path++;
+		goto exit;
+	}
+
+	if (status_flags != counts->expected_statuses[counts->entry_count])
+		counts->wrong_status_flags_count++;
+
+exit:
+	counts->entry_count++;
+	return GIT_SUCCESS;
+}
+
+BEGIN_TEST(statuscb0, "test retrieving status for worktree of repository")
+	git_repository *repo;
+	struct status_entry_counts counts;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	memset(&counts, 0x0, sizeof(struct status_entry_counts));
+	counts.expected_entry_count = ENTRY_COUNT0;
+	counts.expected_paths = entry_paths0;
+	counts.expected_statuses = entry_statuses0;
+
+	must_pass(git_status_foreach(repo, status_cb, &counts));
+	must_be_true(counts.entry_count == counts.expected_entry_count);
+	must_be_true(counts.wrong_status_flags_count == 0);
+	must_be_true(counts.wrong_sorted_path == 0);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+static int status_cb1(const char *GIT_UNUSED(path), unsigned int GIT_UNUSED(status_flags), void *payload)
+{
+	int *count = (int *)payload;;
+
+	GIT_UNUSED_ARG(path);
+	GIT_UNUSED_ARG(status_flags);
+
+	(void) *count++;
+
+	return GIT_SUCCESS;
+}
+
+BEGIN_TEST(statuscb1, "test retrieving status for a worktree of an empty repository")
+	git_repository *repo;
+	int count = 0;
+
+	must_pass(copydir_recurs(EMPTY_REPOSITORY_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(remove_placeholders(TEST_STD_REPO_FOLDER, "dummy-marker.txt"));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	must_pass(git_status_foreach(repo, status_cb1, &count));
+	must_be_true(count == 0);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+static const char *entry_paths2[] = {
+	"current_file",
+	"file_deleted",
+	"modified_file",
+	"staged_changes",
+	"staged_changes_file_deleted",
+	"staged_changes_modified_file",
+	"staged_delete_file_deleted",
+	"staged_delete_modified_file",
+	"staged_new_file",
+	"staged_new_file_deleted_file",
+	"staged_new_file_modified_file",
+	"subdir/current_file",
+	"subdir/deleted_file",
+	"subdir/modified_file",
+};
+
+static const unsigned int entry_statuses2[] = {
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_INDEX_DELETED,
+	GIT_STATUS_INDEX_DELETED,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+};
+
+#define ENTRY_COUNT2 14
+
+BEGIN_TEST(statuscb2, "test retrieving status for a purged worktree of an valid repository")
+	git_repository *repo;
+	struct status_entry_counts counts;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	/* Purging the working */
+	must_pass(p_unlink(TEMP_REPO_FOLDER "current_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "modified_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "new_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "staged_changes"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "staged_changes_modified_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "staged_delete_modified_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "staged_new_file"));
+	must_pass(p_unlink(TEMP_REPO_FOLDER "staged_new_file_modified_file"));
+	must_pass(git_futils_rmdir_r(TEMP_REPO_FOLDER "subdir", 1));
+
+	memset(&counts, 0x0, sizeof(struct status_entry_counts));
+	counts.expected_entry_count = ENTRY_COUNT2;
+	counts.expected_paths = entry_paths2;
+	counts.expected_statuses = entry_statuses2;
+
+	must_pass(git_status_foreach(repo, status_cb, &counts));
+	must_be_true(counts.entry_count == counts.expected_entry_count);
+	must_be_true(counts.wrong_status_flags_count == 0);
+	must_be_true(counts.wrong_sorted_path == 0);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+static const char *entry_paths3[] = {
+	".HEADER",
+	"42-is-not-prime.sigh",
+	"README.md",
+	"current_file",
+	"current_file/current_file",
+	"current_file/modified_file",
+	"current_file/new_file",
+	"file_deleted",
+	"modified_file",
+	"new_file",
+	"staged_changes",
+	"staged_changes_file_deleted",
+	"staged_changes_modified_file",
+	"staged_delete_file_deleted",
+	"staged_delete_modified_file",
+	"staged_new_file",
+	"staged_new_file_deleted_file",
+	"staged_new_file_modified_file",
+	"subdir",
+	"subdir/current_file",
+	"subdir/deleted_file",
+	"subdir/modified_file",
+};
+
+static const unsigned int entry_statuses3[] = {
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_MODIFIED,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED,
+	GIT_STATUS_INDEX_DELETED,
+	GIT_STATUS_WT_NEW | GIT_STATUS_INDEX_DELETED,
+	GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_NEW,
+	GIT_STATUS_WT_NEW,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+	GIT_STATUS_WT_DELETED,
+};
+
+#define ENTRY_COUNT3 22
+
+BEGIN_TEST(statuscb3, "test retrieving status for a worktree where a file and a subdir have been renamed and some files have been added")
+	git_repository *repo;
+	struct status_entry_counts counts;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	must_pass(p_rename(TEMP_REPO_FOLDER "current_file", TEMP_REPO_FOLDER "swap"));
+	must_pass(p_rename(TEMP_REPO_FOLDER "subdir", TEMP_REPO_FOLDER "current_file"));
+	must_pass(p_rename(TEMP_REPO_FOLDER "swap", TEMP_REPO_FOLDER "subdir"));
+
+	must_pass(file_create(TEMP_REPO_FOLDER ".HEADER", "dummy"));
+	must_pass(file_create(TEMP_REPO_FOLDER "42-is-not-prime.sigh", "dummy"));
+	must_pass(file_create(TEMP_REPO_FOLDER "README.md", "dummy"));
+
+	memset(&counts, 0x0, sizeof(struct status_entry_counts));
+	counts.expected_entry_count = ENTRY_COUNT3;
+	counts.expected_paths = entry_paths3;
+	counts.expected_statuses = entry_statuses3;
+
+	must_pass(git_status_foreach(repo, status_cb, &counts));
+	must_be_true(counts.entry_count == counts.expected_entry_count);
+	must_be_true(counts.wrong_status_flags_count == 0);
+	must_be_true(counts.wrong_sorted_path == 0);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_TEST(singlestatus0, "test retrieving status for single file")
+	git_repository *repo;
+	unsigned int status_flags;
+	int i;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	for (i = 0; i < ENTRY_COUNT0; ++i) {
+		must_pass(git_status_file(&status_flags, repo, entry_paths0[i]));
+		must_be_true(status_flags == entry_statuses0[i]);
+	}
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_TEST(singlestatus1, "test retrieving status for nonexistent file")
+	git_repository *repo;
+	unsigned int status_flags;
+	int error;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	// "nonexistent" does not exist in HEAD, Index or the worktree
+	error = git_status_file(&status_flags, repo, "nonexistent");
+	must_be_true(error == GIT_ENOTFOUND);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_TEST(singlestatus2, "test retrieving status for a non existent file in an empty repository")
+	git_repository *repo;
+	unsigned int status_flags;
+	int error;
+
+	must_pass(copydir_recurs(EMPTY_REPOSITORY_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(remove_placeholders(TEST_STD_REPO_FOLDER, "dummy-marker.txt"));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	error = git_status_file(&status_flags, repo, "nonexistent");
+	must_be_true(error == GIT_ENOTFOUND);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_TEST(singlestatus3, "test retrieving status for a new file in an empty repository")
+	git_repository *repo;
+	unsigned int status_flags;
+	char file_path[GIT_PATH_MAX];
+	char filename[] = "new_file";
+	int fd;
+
+	must_pass(copydir_recurs(EMPTY_REPOSITORY_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(remove_placeholders(TEST_STD_REPO_FOLDER, "dummy-marker.txt"));
+
+	git_path_join(file_path, TEMP_REPO_FOLDER, filename);
+	fd = p_creat(file_path, 0666);
+	must_pass(fd);
+	must_pass(p_write(fd, "new_file\n", 9));
+	must_pass(p_close(fd));
+
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	must_pass(git_status_file(&status_flags, repo, filename));
+	must_be_true(status_flags == GIT_STATUS_WT_NEW);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_TEST(singlestatus4, "can't determine the status for a folder")
+	git_repository *repo;
+	unsigned int status_flags;
+	int error;
+
+	must_pass(copydir_recurs(STATUS_WORKDIR_FOLDER, TEMP_REPO_FOLDER));
+	must_pass(p_rename(STATUS_REPOSITORY_TEMP_FOLDER, TEST_STD_REPO_FOLDER));
+	must_pass(git_repository_open(&repo, TEST_STD_REPO_FOLDER));
+
+	error = git_status_file(&status_flags, repo, "subdir");
+	must_be_true(error == GIT_EINVALIDPATH);
+
+	git_repository_free(repo);
+
+	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
+END_TEST
+
+BEGIN_SUITE(status)
+	ADD_TEST(file0);
+
+	ADD_TEST(statuscb0);
+	ADD_TEST(statuscb1);
+	ADD_TEST(statuscb2);
+	ADD_TEST(statuscb3);
+
+	ADD_TEST(singlestatus0);
+	ADD_TEST(singlestatus1);
+	ADD_TEST(singlestatus2);
+	ADD_TEST(singlestatus3);
+	ADD_TEST(singlestatus4);
+END_SUITE