Add sample "Status" clay tests

CMakeLists.txt

@@ -114,11 +114,11 @@ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libgit2.pc DESTINATION ${INSTALL_LIB}/
 INSTALL(DIRECTORY include/git2 DESTINATION ${INSTALL_INC} )
 INSTALL(FILES include/git2.h DESTINATION ${INSTALL_INC} )
 
-SET(TEST_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/tests/resources" CACHE PATH "Path to test resources.")
-ADD_DEFINITIONS(-DTEST_RESOURCES=\"${TEST_RESOURCES}\")
-
 # Tests
 IF (BUILD_TESTS)
+	SET(TEST_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/tests/resources" CACHE PATH "Path to test resources.")
+	ADD_DEFINITIONS(-DTEST_RESOURCES=\"${TEST_RESOURCES}\")
+
     INCLUDE_DIRECTORIES(tests)
 	FILE(GLOB SRC_TEST tests/t??-*.c)
 
@@ -135,6 +135,9 @@ IF (BUILD_TESTS)
 ENDIF ()
 
 IF (BUILD_CLAY)
+	SET(CLAY_FIXTURES "${CMAKE_CURRENT_SOURCE_DIR}/tests/resources/")
+	ADD_DEFINITIONS(-DCLAY_FIXTURE_PATH=\"${CLAY_FIXTURES}\")
+
     INCLUDE_DIRECTORIES(tests-clay)
 	FILE(GLOB_RECURSE SRC_TEST tests-clay/*.c)
 

tests-clay/clay

@@ -81,7 +81,7 @@ class ClayTestBuilder:
         self.suites = []
         self.suite_list = []
 
-        self.clay_path = os.path.abspath(clay_path)
+        self.clay_path = os.path.abspath(clay_path) if clay_path else None
         self.print_mode = print_mode
 
         folder_name = os.path.abspath(folder_name)
@@ -91,7 +91,7 @@ class ClayTestBuilder:
         self.output = os.path.join(output_folder, "clay_main.c")
         self.output_header = os.path.join(output_folder, "clay.h")
 
-        self.modules = ["clay.c", "clay_sandbox.c"]
+        self.modules = ["clay.c", "clay_sandbox.c", "clay_fixtures.c", "clay_fs.c"]
 
         print("Loading test suites...")
 
@@ -217,9 +217,11 @@ class ClayTestBuilder:
         print("  %s (%d tests)" % (clean_name, len(callbacks)))
 
 CLAY_FILES = {
-"clay.c" : r"""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""",
-"clay_sandbox.c" : r"""eJx9VW1P2zAQ/pz8iiNoNKEZDRvaNGX9MIkyVRSoCohJtIpC4lCLxOlst1o3+O+7S0KalJeqamLf47vnOd9dd3kSswSCm+H550/mroELLhiMRz+uTi4mZ8HlYAyd6bRj7rJUsbcAPbKLmCemqXSoeQTRPJQQRGm4Dhahnt8eed++zPzazIU2uQpWYcrjQGeLAmRHuVC6PLpPG475zzSUlstIAx3EH980JNNLKcBOacsmnAt7SjvQ74MHe3umYdiXwfDyeDixlT5QOsjymDnw+IgWMozOT5sGpzwTRhFTqvJ3E1yclg4d33xq0Ub5TcoF2btlkjDpguJ/WaAhZeK+Zl+mo1BWmVehDKJ8KTT04cjfwpQOmVhhcqS6nSEG3RjW1dkYBVku0FvxGJTP68vBZDy5OBmOBpYJxhMmGYwqEsfFbuuGDZ6A/ZPpK5YtxiTAPr65mBw7JWUXSiWOgyGrPB/69d0aSS7B5kjJ84HD940SH7pd7hRMt2Qg+J5pfLFrTXyGSTUKJju4SbHolOZiyZBwaXlZHQQtQ1BNiGixtp/zjib3OevkusHdMJ5M/JpGbx+GCeg5IzSXucgY3kCcMyU6eDXhGkKx1nMu7l3Qcg06h6Vi0MP4sN8z3yBlkd2qeG3TKo0tZg1iFamrOVeg1kqzrGaT8geG0VtEiHm0lLJgzSWLdI7Gd5gdvEnr4F1O1dLbKnyIUhaKIMnTmMnXW7WxmasgymIq3+0CNCwZQ09B7zdMrQ9qall+NVzIlMFHmTQNVeUVTqM8y0IRPw8TQ4mFRGaJXRnKBszrteNWPFwoOG6GR5nvGteUusp5DMXgWgqFxrv8j017hUJKdWOqeTOaEZ2p19k0DFVwK1Ub/PYsKcO8CNJII50KdMjTYhBYBZ5u+FfxsSgH9cihwEVPtSfUJnydngajZqd75AEdYSQsGXxpU3+hnqAf4XAGO/3W/0FZdW1gt0sCmqiq2jAS1eYGDV0S426k16GzB7yzRZMUZf/8ejTaFlGisUta6r2vnucQWe81fDRv419HbnoFyf8Hmxc92w==""",
-"clay.h" : r"""eJy9VUFvmzAUPpdf8RYuAaEmu3ZdpapKtEqol2WaerJc+1GsOTazzZr9+9lAkoaA2HbICfPw5+97733PxKJQHAsg5CG/fyab1dcN+UJIFPugUHgWj2KhmKw5wq11XIqX6/Iuin5pwYFJ+psQai0aN4+uhHLAtOLCCa2y6MqvrY+U1EBaCIlZu0V6lt5XNEabXoyjZUZU3VkBaEtdS07oizYu+XTQQCw6wiRSVVfzJjZPu9ekfU+TDNqFrujPGgN4kaYRpHDfiPccsKXMaAtvwpWAu0oKJhw0wmCL1tJX9PsXhzJ53m1tHal8+mTuASaDIDk5rUrzJYG7z7DMfGnXj/mKkLDKH5+a1WxdK9YIYFRKKKgvFL+BGcTHMzP4mJwRh53TxLejvKtdhcwhh+JEgNONhgkFLck0/YfxvD2/8XUNxMKC0g6cqXGId9+rhxLZj//oEwu4CzVqmZwzX7hTQxIu0KhlMjFUSv/lOHWSTiesDWbw9C3Ph4ehB2urPgrr0j9g9o4+BYxbbyqbo+mOHO+NOCrs6Jk+cCKjZlMf089nn9BaGxYc5Y+sDS7eqFFCvfaTaFQMmGbMKhv013c7Gdez4ZujY/qXU7+3EOC1CQ8XSHCHrA4Wu5m9N2CM/vdTRH8A5MtAqA=="""
+"clay.c" : r"""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""",
+"clay_sandbox.c" : r"""eJyNlW1P2zAQx187n+IIEk1ooWFDm6aOF5NgUzVGq7YIJKiikDjUWuNUttutIL77znbaPBTQqkpxcufz7+7+l0gVKRZDPIsEhPE8WoeLSM3uToMvn6Y9x5HWzLhymAxX0ZwlocoWxsmLcy6V3XqoH/jOs0PGk2+TcAJS4W7CUvB0CE+bO3AglQ97ZxD4DiGCqqXgEGz89sZhf3zeH+GGY6nCLE+o3/Qr1l4Ux1TKIupNOPjpw5kO23Neaswp41VeQ/qwTFMqOiDZEw0VzCl/LNCLjTatwryKRBjnS67gDE57DR8bkPIVVkbIuyn6YBjiTn4NMRG3A3plLhf2ej2+GA1Hg+/9ywvXAfKCOQEpTmJ4s8/ShKYQ3vSvPn6wZflB1YRmi6FOwDu/GYzOfYvcAZtJo0j7lCcsxVqluQCPIVLQAwZfy0x60G4z35A20kDnR6pw4W1zYlMsKrENwof6LL1LMb6kuiPGsisN7WqPwIoJHi/W3qbuaOpsqq5DV9gJeXHw75DuIfRTUDOqvZnIeUaxA0lOJW9ha6I1RHytZow/dkCJNagclpJCF8+Hw67zBpSr7W7B1cSyxhpZBayAmsyYBLmWimZbmjn7TfH0Gogmj5dCGGomaKxyNL5Ddvwm1vG7TMXt0UlV+aucJWBmecllxJOH/K+nnxmRa4DKoAdTPTmt+6BVymhXiPEMs0BKxKwqTIYiqwRrjh8KlM2TsECwmW45KtLThlBFbG4myDXxdGluzc/VU7ed1c3boj7ZJYOd6zytYvmo/uorR1fLIRgMT8N646KeRDP7Z8DW81xk2LQnanB1o4eDcf8WcMz+RCIBOY/kjErT5MpIk5051EmUE9jsByv6cW/6QUjDBK1uazsn20Y0YujMjuBkql+16G8Pqtvb7TKY1hGWQauudIK2Bu2UvfE3lc9+o/oX1Ypp4qvry8udEpdirevCbP1/ZcLBwWtSer2tFlHLtSqK4HMQ7Hx6yg1W39WUXnWt5fMPA9kzbQ==""",
+"clay_fixtures.c" : r"""eJyFUV1LwzAUfW5+xZU9rLUVJ4ggZQ9DFAUfRCZMRglZmrBAl5Qkk03xv9v0a82U+Zabc+45595rLLGCAlXSWKBrouEccbGzW81wSew6HCIrYljicTuqJBsWoS8UmFbPobXA8npye5OlFSI+GbaglbK4YDJFKOjeMAVjdfUInUPkyFZLWu7DWiKBxtgpKN78RZETEByactlLXcBVBmdTGF+OIxQEPhrHGdRQ1zzMv5xUYN84ROLY8b1MEPeTJEdsV3tRq0wdt06tWcWVzXpS9I3QSPCccbh7nr3jh6fF/O31Hr/M5o9ouGpa4NYlPHmBVt074i/lBLy+OsWHEjkcXLAhMl+p3Wk3bjBV1VIG6TxOApgWZN8s4k8bWjAit+W/NnoTejMddI+GqW1GTOaCox8pOffr""",
+"clay_fs.c" : r"""eJylVdtu20YQfSa/YkAD8TKWY8dJX6L0wXDEVqgsBhINN7UFhiGX1qIkl9hd+dLG/57ZCynJUWEkfZE0s7NnZufMGe2xsqAlpJfj6ZsT399DgzUUojhKo8npb3Mg+ud8PBlNE/hq/NP4LJ5G49n5aTKOp71zNJvFs4vx06DzPz6MZ6HvS5UplkO+zAS89EtWUd7KtM3UkuS8kcqdGE/o/+t71tYm/ArTi8lk6HuS/UNTBRVtbtRyAGzo+x4rgaQ2zMaFvucJqlaicdd8z15AHKkE/rbxIQI6+DqrKp4TF3YAJ2GH/AxwTeu8fTBRA0jtl0Xp0K+sucAsx9suzPPauX2v5AIIMxYweO9AhnBwwELAbvTFXLGFrmf/aF+X4/Uu2L++3scEjwjmitRnQ/+x7/0tZ0XXecIaBTUv6AC22i/5SuRPnQWVynAy/z3CSYg/zpPZxVkCJQLp4m2YvYqVbJHrEHU7bJgG+y7IZNBQf1HBz2nNxQN5oeEHoDnnJdlOHYa2aa18dRetmlxziI8ZOl8bCV5ruk3u3ptw9OlUnaeMquxGorOfd/OcKs2kpEKlBFuMibHUuKUCm8gbW1aoOTge4HFwyZqC30l4EgdlhmYR+J4tVVBK1q0wpnv0U4JkKmqygxTDQEdfFKcfRpNRMsKx6zgzM7oLL+c4oz9A80aSs/jjp40U6bpmA46t0vgVzZpVS7TLApg3lOwe55A6ivMqe3AKCV4GoQXZo5WkXbk4kr5c0qpK+UoRW5SrMBM3t1cLg60HV19YSS0nVuA+wE/dY/zSg8XF32StX/S9h2OrobIVeLskUhVUCM2eF8wfpKI1oM3FO/hsb3+GHDeCo/DVdRNozjx6zxQ5fB06lXXwehIsPr2n+S0xtR4vBqboLvguYwqD9YUBvLD1D/DesFfr5ejPcTJPTpOLObHn/4PLnkprmpJ+WQy3pbpeqNZOcenovvVCxm1ZIK0bEl4Hrpdpf2pbYs2rjchDs+f6nfVfAXYRuu6hGRx9Yc1R3gZD5zVBweGsd5wsNjVuXG+0y81O6KRuDt4u+r8Ro/B6JRWOo5RG5OuxM6QZYUeGfVAcdM9B6b3lRlpqr8ya4gu/363wZ0W9oekNjt4udvVA1N/1oNxuQvfiHc342TdbTYNa0u2XPiN9I/NV464Qs/e1a8PxiLJvClb63wD3Q6FA""",
+"clay.h" : r"""eJy9VF1v2jAUfW5+xR15IVFU2GvXVkIVqEiomjaqbU+WcW6KtWBntrOyfz/bCR8JpFn3wBPmxsfn3HuOHfJMpJgBIQ+LyQ+ynH5dkkdCgtAWucCTehBywfIyRbjVJs356np9HwS/JU+B5fQPIVRrVGYYXHFhgEmRcsOlSIIru9a2sqYK4oznmFRbcsvS+opKSdWqpaiZ4kV9lgPqtSzzlNCVVCb6tNdANBrCcqSiLIa+Nozrv1H1P44SqBayoL9KtOAdNtMNqDs25Jmbj5/CbP59+fxlSj5Plo/BsToH5VtTKhw22/Q1IuimwVKXNRXpSm7fA9mpewMSop15FgSjOA4ghon3w44NNpQpqeGVmzXgtsg54wb8rGGDWtMXtPtHe+ct66bUhhTWUTK0AJWAcyFqGu2/RHB/B+PEpmU2X0wJcavF/MmvBrNSMC+A0TyHjFrv0xsYQHg4M4GP0Qmx29lPfNvJO90WyAymkDUEGOk19CioSPrpP3T3bfmVnasj5hqENGBUied4d149rJH9/A+fmMNdyKhxdMp8YafOSbiAUeOo51IJ+Y/XqZbUvGFVMYGn58Xi/GVowaqpd8Lq9veYXaKbgO7o9XVzCN2B4ziIncIOmWkDezrym9qYdj+7hmZSMZcoe6R9HEevVAkuXtpNeBVnQtMVlSXaZ7e6GdeD8y9HzfSeU79VEEhL5X6MI8EtstJF7GZwHMD6df8LLiKMPg=="""
 }
 
 if __name__ == '__main__':

tests-clay/clay.h

@@ -12,6 +12,13 @@ void clay__assert(
 	int should_abort);
 
 void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
+void cl_fs_cleanup(void);
+
+#ifdef CLAY_FIXTURE_PATH
+const char *cl_fixture(const char *fixture_name);
+void cl_fixture_sandbox(const char *fixture_name);
+void cl_fixture_cleanup(const char *fixture_name);
+#endif
 
 /**
  * Assertion macros with explicit error message

tests-clay/clay_main.c

@@ -17,11 +17,36 @@
 #include <math.h>
 
 /* required for sandboxing */
+#include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h>
+
+#ifdef _WIN32
+#	include <windows.h>
+#	include <io.h>
+#	include <Shellapi.h>
+#	pragma comment(lib, "shell32")
+
+#	define stat(path, st) _stat(path, st)
+#	define mkdir(path, mode) _mkdir(path)
+#	define access(path, mode) _access(path, mode)
+#	define mktemp(path) _mktemp(path)
+
+#	define W_OK 02
+#	define S_ISDIR(x) (x & _S_IFDIR) != 0
+	typedef struct _stat STAT_T;
+#else
+#	include <unistd.h>
+	typedef struct stat STAT_T;
+#endif
 
 #include "clay.h"
 
+static void fs_rm(const char *_source);
+static void fs_copy(const char *_source, const char *dest);
+
+static const char *
+fixture_path(const char *base, const char *fixture_name);
+
 struct clay_error {
 	const char *test;
 	int test_number;
@@ -243,7 +268,7 @@ clay_test(
 {
 	clay_print("Loaded %d suites: %s\n", (int)suite_count, suites_str);
 
-	if (!clay_sandbox()) {
+	if (clay_sandbox() < 0) {
 		fprintf(stderr,
 			"Failed to sandbox the test runner.\n"
 			"Testing will proceed without sandboxing.\n");
@@ -310,7 +335,7 @@ clay__assert(
 	if (should_abort) {
 		if (!_clay.trampoline_enabled) {
 			fprintf(stderr,
-				"Unhandled exception: a cleanup method raised an exception.");
+				"Fatal error: a cleanup method raised an exception.");
 			exit(-1);
 		}
 
@@ -324,22 +349,20 @@ void cl_set_cleanup(void (*cleanup)(void *), void *opaque)
 	_clay.local_cleanup_payload = opaque;
 }
 
-#ifdef _WIN32
-#	define PLATFORM_SEP '\\'
-#else
-#	define PLATFORM_SEP '/'
-#endif
-
 static char _clay_path[4096];
 
 static int
 is_valid_tmp_path(const char *path)
 {
-	struct stat st;
-	return (lstat(path, &st) == 0 &&
-		(S_ISDIR(st.st_mode) ||
-		S_ISLNK(st.st_mode)) &&
-		access(path, W_OK) == 0);
+	STAT_T st;
+
+	if (stat(path, &st) != 0)
+		return 0;
+
+	if (!S_ISDIR(st.st_mode))
+		return 0;
+
+	return (access(path, W_OK) == 0);
 }
 
 static int
@@ -354,7 +377,7 @@ find_tmp_path(char *buffer, size_t length)
 
 #ifdef _WIN32
 	if (GetTempPath((DWORD)length, buffer))
-		return 1;
+		return 0;
 #endif
 
 	for (i = 0; i < var_count; ++i) {
@@ -364,37 +387,23 @@ find_tmp_path(char *buffer, size_t length)
 
 		if (is_valid_tmp_path(env)) {
 			strncpy(buffer, env, length);
-			return 1;
+			return 0;
 		}
 	}
 
 	/* If the environment doesn't say anything, try to use /tmp */
 	if (is_valid_tmp_path("/tmp")) {
 		strncpy(buffer, "/tmp", length);
-		return 1;
+		return 0;
 	}
 
 	/* This system doesn't like us, try to use the current directory */
 	if (is_valid_tmp_path(".")) {
 		strncpy(buffer, ".", length);
-		return 1;
+		return 0;
 	}
 
-	return 0;
-}
-
-static int clean_folder(const char *path)
-{
-	const char os_cmd[] =
-#ifdef _WIN32
-		"rd /s /q \"%s\"";
-#else
-		"rm -rf \"%s\"";
-#endif
-
-	char command[4096];
-	snprintf(command, sizeof(command), os_cmd, path);
-	return system(command);
+	return -1;
 }
 
 static void clay_unsandbox(void)
@@ -402,37 +411,245 @@ static void clay_unsandbox(void)
 	if (_clay_path[0] == '\0')
 		return;
 
-	clean_folder(_clay_path);
+#ifdef _WIN32
+	chdir("..");
+#endif
+
+	fs_rm(_clay_path);
 }
 
-static int clay_sandbox(void)
+static int build_sandbox_path(void)
 {
 	const char path_tail[] = "clay_tmp_XXXXXX";
 	size_t len;
 
-	if (!find_tmp_path(_clay_path, sizeof(_clay_path)))
-		return 0;
+	if (find_tmp_path(_clay_path, sizeof(_clay_path)) < 0)
+		return -1;
 
 	len = strlen(_clay_path);
 
-	if (_clay_path[len - 1] != PLATFORM_SEP) {
-		_clay_path[len++] = PLATFORM_SEP;
+#ifdef _WIN32
+	{ /* normalize path to POSIX forward slashes */
+		size_t i;
+		for (i = 0; i < len; ++i) {
+			if (_clay_path[i] == '\\')
+				_clay_path[i] = '/';
+		}
+	}
+#endif
+
+	if (_clay_path[len - 1] != '/') {
+		_clay_path[len++] = '/';
 	}
 
 	strcpy(_clay_path + len, path_tail);
 
 	if (mktemp(_clay_path) == NULL)
-		return 0;
+		return -1;
+
+	return 0;
+}
+
+static int clay_sandbox(void)
+{
+	if (_clay_path[0] == '\0' && build_sandbox_path() < 0)
+		return -1;
 
 	if (mkdir(_clay_path, 0700) != 0)
-		return 0;
+		return -1;
 
 	if (chdir(_clay_path) != 0)
-		return 0;
+		return -1;
+
+	return 0;
+}
+
+
+static const char *
+fixture_path(const char *base, const char *fixture_name)
+{
+	static char _path[4096];
+	size_t root_len;
+
+	root_len = strlen(base);
+	strncpy(_path, base, sizeof(_path));
+
+	if (_path[root_len - 1] != '/')
+		_path[root_len++] = '/';
+
+	if (fixture_name[0] == '/')
+		fixture_name++;
+
+	strncpy(_path + root_len,
+		fixture_name,
+		sizeof(_path) - root_len);
+
+	return _path;
+}
+
+#ifdef CLAY_FIXTURE_PATH
+const char *cl_fixture(const char *fixture_name)
+{
+	return fixture_path(CLAY_FIXTURE_PATH, fixture_name);
+}
+
+void cl_fixture_sandbox(const char *fixture_name)
+{
+	fs_copy(cl_fixture(fixture_name), _clay_path);
+}
+
+void cl_fixture_cleanup(const char *fixture_name)
+{
+	fs_rm(fixture_path(_clay_path, fixture_name));
+}
+#endif
+
+#ifdef _WIN32
+
+#define FOF_FLAGS (FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR)
+
+static char *
+fileops_path(const char *_path)
+{
+	char *path = NULL;
+	size_t length, i;
+
+	if (_path == NULL)
+		return NULL;
+
+	length = strlen(_path);
+	path = malloc(length + 2);
+
+	if (path == NULL)
+		return NULL;
+
+	memcpy(path, _path, length);
+	path[length] = 0;
+	path[length + 1] = 0;
+
+	for (i = 0; i < length; ++i) {
+		if (path[i] == '/')
+			path[i] = '\\';
+	}
 
-	return 1;
+	return path;
 }
 
+static void
+fileops(int mode, const char *_source, const char *_dest)
+{
+	SHFILEOPSTRUCT fops;
+
+	char *source = fileops_path(_source);
+	char *dest = fileops_path(_dest);
+
+	ZeroMemory(&fops, sizeof(SHFILEOPSTRUCT));
+
+	fops.wFunc = mode;
+	fops.pFrom = source;
+	fops.pTo = dest;
+	fops.fFlags = FOF_FLAGS;
+
+	cl_assert_(
+		SHFileOperation(&fops) == 0,
+		"Windows SHFileOperation failed"
+	);
+
+	free(source);
+	free(dest);
+}
+
+static void
+fs_rm(const char *_source)
+{
+	fileops(FO_DELETE, _source, NULL);
+}
+
+static void
+fs_copy(const char *_source, const char *_dest)
+{
+	fileops(FO_COPY, _source, _dest);
+}
+
+void
+cl_fs_cleanup(void)
+{
+	fs_rm(fixture_path(_clay_path, "*"));
+}
+
+#else
+static int
+shell_out(char * const argv[])
+{
+	int status;
+	pid_t pid;
+
+	pid = fork();
+
+	if (pid < 0) {
+		fprintf(stderr,
+			"System error: `fork()` call failed.\n");
+		exit(-1);
+	}
+
+	if (pid == 0) {
+		execv(argv[0], argv);
+	}
+
+	waitpid(pid, &status, 0);
+	return WEXITSTATUS(status);
+}
+
+static void
+fs_copy(const char *_source, const char *dest)
+{
+	char *argv[5];
+	char *source;
+	size_t source_len;
+
+	source = strdup(_source);
+	source_len = strlen(source);
+
+	if (source[source_len - 1] == '/')
+		source[source_len - 1] = 0;
+
+	argv[0] = "/bin/cp";
+	argv[1] = "-R";
+	argv[2] = source;
+	argv[3] = (char *)dest;
+	argv[4] = NULL;
+
+	cl_must_pass_(
+		shell_out(argv),
+		"Failed to copy test fixtures to sandbox"
+	);
+
+	free(source);
+}
+
+static void
+fs_rm(const char *source)
+{
+	char *argv[4];
+
+	argv[0] = "/bin/rm";
+	argv[1] = "-Rf";
+	argv[2] = (char *)source;
+	argv[3] = NULL;
+
+	cl_must_pass_(
+		shell_out(argv),
+		"Failed to cleanup the sandbox"
+	);
+}
+
+void
+cl_fs_cleanup(void)
+{
+	clay_unsandbox();
+	clay_sandbox();
+}
+#endif
 
 
 extern void test_core_dirent__dont_traverse_dot(void);
@@ -456,6 +673,11 @@ extern void test_core_string__1(void);
 extern void test_core_vector__0(void);
 extern void test_core_vector__1(void);
 extern void test_core_vector__2(void);
+extern void test_status_single__hash_single_file();
+extern void test_status_worktree__initialize();
+extern void test_status_worktree__cleanup();
+extern void test_status_worktree__whole_repository();
+extern void test_status_worktree__empty_repository();
 
 static const struct clay_func _all_callbacks[] = {
     {"dont_traverse_dot", &test_core_dirent__dont_traverse_dot, 0},
@@ -477,7 +699,10 @@ static const struct clay_func _all_callbacks[] = {
 	{"1", &test_core_string__1, 4},
 	{"0", &test_core_vector__0, 5},
 	{"1", &test_core_vector__1, 5},
-	{"2", &test_core_vector__2, 5}
+	{"2", &test_core_vector__2, 5},
+	{"hash_single_file", &test_status_single__hash_single_file, 6},
+	{"whole_repository", &test_status_worktree__whole_repository, 7},
+	{"empty_repository", &test_status_worktree__empty_repository, 7}
 };
 
 static const struct clay_suite _all_suites[] = {
@@ -516,16 +741,28 @@ static const struct clay_suite _all_suites[] = {
         {NULL, NULL, 0},
         {NULL, NULL, 0},
         &_all_callbacks[17], 3
+    },
+	{
+        "status::single",
+        {NULL, NULL, 0},
+        {NULL, NULL, 0},
+        &_all_callbacks[20], 1
+    },
+	{
+        "status::worktree",
+        {"initialize", &test_status_worktree__initialize, 7},
+        {"cleanup", &test_status_worktree__cleanup, 7},
+        &_all_callbacks[21], 2
     }
 };
 
-static const char _suites_str[] = "core::dirent, core::filebuf, core::path, core::rmdir, core::string, core::vector";
+static const char _suites_str[] = "core::dirent, core::filebuf, core::path, core::rmdir, core::string, core::vector, status::single, status::worktree";
 
 int main(int argc, char *argv[])
 {
     return clay_test(
         argc, argv, _suites_str,
-        _all_callbacks, 20,
-        _all_suites, 6
+        _all_callbacks, 23,
+        _all_suites, 8
     );
 }

tests-clay/status/single.c

+#include "clay_libgit2.h"
+#include "posix.h"
+
+static void
+cleanup__remove_file(void *_file)
+{
+	cl_must_pass(p_unlink((char *)_file));
+}
+
+static void
+file_create(const char *filename, const char *content)
+{
+	int fd = p_creat(filename, 0644);
+	cl_assert(fd >= 0);
+	cl_must_pass(p_write(fd, content, strlen(content)));
+	cl_must_pass(p_close(fd));
+}
+
+/* test retrieving OID from a file apart from the ODB */
+void test_status_single__hash_single_file()
+{
+	static const char file_name[] = "new_file";
+	static const char file_contents[] = "new_file\n";
+	static const char file_hash[] = "d4fa8600b4f37d7516bef4816ae2c64dbf029e3a";
+
+	git_oid expected_id, actual_id;
+
+	/* initialization */
+	git_oid_fromstr(&expected_id, file_hash);
+	file_create(file_name, file_contents);
+	cl_set_cleanup(&cleanup__remove_file, (void *)file_name);
+
+	cl_git_pass(git_odb_hashfile(&actual_id, file_name, GIT_OBJ_BLOB));
+	cl_assert(git_oid_cmp(&expected_id, &actual_id) == 0);
+}
+
+
+

tests-clay/status/status_data.h

+
+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 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,
+};
+
+static const size_t entry_count0 = 14;
+

tests-clay/status/worktree.c

+#include "clay_libgit2.h"
+#include "fileops.h"
+#include "status_data.h"
+
+
+/**
+ * Test fixtures
+ */
+static git_repository *_repository = NULL;
+
+
+/**
+ * Auxiliary methods
+ */
+static int
+cb_status__normal( const char *path, unsigned int status_flags, void *payload)
+{
+	struct status_entry_counts *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;
+}
+
+static int
+cb_status__count(const char *GIT_UNUSED(p), unsigned int GIT_UNUSED(s), void *payload)
+{
+	volatile int *count = (int *)payload;
+
+	GIT_UNUSED_ARG(path);
+	GIT_UNUSED_ARG(status_flags);
+
+	*count++;
+
+	return GIT_SUCCESS;
+}
+
+
+
+/**
+ * Initializer
+ *
+ * This method is called once before starting each
+ * test, and will load the required fixtures
+ */
+void test_status_worktree__initialize()
+{
+	/*
+	 * Sandbox the `status/` repository from our Fixtures.
+	 * This will copy the whole folder to our sandbox,
+	 * so now it can be accessed with `./status`
+	 */
+	cl_fixture_sandbox("status");
+
+	/*
+	 * Rename `status/.gitted` to `status/.git`
+	 * We do this because we cannot store a folder named `.git`
+	 * inside the fixtures folder in our libgit2 repo.
+	 */
+	cl_git_pass(
+		git_futils_mv_atomic("status/.gitted", "status/.git")
+	);
+
+	/*
+	 * Open the sandboxed "status" repository
+	 */
+	cl_git_pass(git_repository_open(&_repository, "status/.git"));
+}
+
+/**
+ * Cleanup
+ *
+ * This will be called once after each test finishes, even
+ * if the test failed
+ */
+void test_status_worktree__cleanup()
+{
+	git_repository_free(_repository);
+	_repository = NULL;
+
+	cl_fixture_cleanup("status");
+}
+
+/**
+ * Tests - Status determination on a working tree
+ */
+void test_status_worktree__whole_repository()
+{
+	struct status_entry_counts counts;
+
+	memset(&counts, 0x0, sizeof(struct status_entry_counts));
+	counts.expected_entry_count = entry_count0;
+	counts.expected_paths = entry_paths0;
+	counts.expected_statuses = entry_statuses0;
+
+	git_status_foreach(_repository, cb_status__normal, &counts);
+
+	cl_assert(counts.entry_count == counts.expected_entry_count);
+	cl_assert(counts.wrong_status_flags_count == 0);
+	cl_assert(counts.wrong_sorted_path == 0);
+}
+
+void test_status_worktree__empty_repository()
+{
+	int count = 0;
+
+	git_status_foreach(_repository, cb_status__count, &count);
+	cl_assert(count == 0);
+}

tests/t18-status.c

@@ -48,20 +48,6 @@ static int file_create(const char *filename, const char *content)
 	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",
@@ -100,15 +86,6 @@ static const unsigned int entry_statuses0[] = {
 
 #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;
@@ -154,18 +131,6 @@ BEGIN_TEST(statuscb0, "test retrieving status for worktree of repository")
 	git_futils_rmdir_r(TEMP_REPO_FOLDER, 1);
 END_TEST
 
-static int status_cb1(const char *path, unsigned int status_flags, void *payload)
-{
-	int *count = (int *)payload;;
-
-	GIT_UNUSED_ARG(path);
-	GIT_UNUSED_ARG(status_flags);
-
-	*count++;
-
-	return GIT_SUCCESS;
-}
-
 BEGIN_TEST(statuscb1, "test retrieving status for a worktree of an empty repository")
 	git_repository *repo;
 	int count = 0;
@@ -445,4 +410,4 @@ BEGIN_SUITE(status)
 	ADD_TEST(singlestatus2);
 	ADD_TEST(singlestatus3);
 	ADD_TEST(singlestatus4);
-END_SUITE
+END_SUITE
\ No newline at end of file