rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/core/dirent.c

@@ -1,4 +1,4 @@
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 #include "fileops.h"
 
 typedef struct name_data {
@@ -9,10 +9,10 @@ typedef struct name_data {
 typedef struct walk_data {
 	char *sub;		/* sub-directory name */
 	name_data *names; /* name state data	*/
+	git_buf path;
 } walk_data;
 
 
-static char path_buffer[GIT_PATH_MAX];
 static char *top_dir = "dir-walk";
 static walk_data *state_loc;
 
@@ -27,7 +27,8 @@ static void setup(walk_data *d)
 	if (strcmp(d->sub, ".") != 0)
 		cl_must_pass(p_mkdir(d->sub, 0777));
 
-	strcpy(path_buffer, d->sub);
+	cl_git_pass(git_buf_sets(&d->path, d->sub));
+
 	state_loc = d;
 
 	for (n = d->names; n->name; n++) {
@@ -53,6 +54,8 @@ static void dirent_cleanup__cb(void *_d)
 	cl_must_pass(p_chdir(".."));
 
 	cl_must_pass(p_rmdir(top_dir));
+
+	git_buf_free(&d->path);
 }
 
 static void check_counts(walk_data *d)
@@ -64,7 +67,7 @@ static void check_counts(walk_data *d)
 	}
 }
 
-static int one_entry(void *state, char *path)
+static int one_entry(void *state, git_buf *path)
 {
 	walk_data *d = (walk_data *) state;
 	name_data *n;
@@ -72,11 +75,11 @@ static int one_entry(void *state, char *path)
 	if (state != state_loc)
 		return GIT_ERROR;
 
-	if (path != path_buffer)
+	if (path != &d->path)
 		return GIT_ERROR;
 
 	for (n = d->names; n->name; n++) {
-		if (!strcmp(n->name, path)) {
+		if (!strcmp(n->name, path->ptr)) {
 			n->count++;
 			return 0;
 		}
@@ -85,10 +88,10 @@ static int one_entry(void *state, char *path)
 	return GIT_ERROR;
 }
 
-static int dont_call_me(void *GIT_UNUSED(state), char *GIT_UNUSED(path))
+static int dont_call_me(void *state, git_buf *path)
 {
-	GIT_UNUSED_ARG(state)
-	GIT_UNUSED_ARG(path)
+	GIT_UNUSED(state);
+	GIT_UNUSED(path);
 	return GIT_ERROR;
 }
 
@@ -102,7 +105,8 @@ static name_data dot_names[] = {
 };
 static walk_data dot = {
 	".",
-	dot_names
+	dot_names,
+	GIT_BUF_INIT
 };
 
 /* make sure that the '.' folder is not traversed */
@@ -111,8 +115,7 @@ void test_core_dirent__dont_traverse_dot(void)
 	cl_set_cleanup(&dirent_cleanup__cb, &dot);
 	setup(&dot);
 
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&dot.path,
 					one_entry,
 					&dot));
 
@@ -128,7 +131,8 @@ static name_data sub_names[] = {
 };
 static walk_data sub = {
 	"sub",
-	sub_names
+	sub_names,
+	GIT_BUF_INIT
 };
 
 /* traverse a subfolder */
@@ -137,8 +141,7 @@ void test_core_dirent__traverse_subfolder(void)
 	cl_set_cleanup(&dirent_cleanup__cb, &sub);
 	setup(&sub);
 
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&sub.path,
 					one_entry,
 					&sub));
 
@@ -148,7 +151,8 @@ void test_core_dirent__traverse_subfolder(void)
 
 static walk_data sub_slash = {
 	"sub/",
-	sub_names
+	sub_names,
+	GIT_BUF_INIT
 };
 
 /* traverse a slash-terminated subfolder */
@@ -157,8 +161,7 @@ void test_core_dirent__traverse_slash_terminated_folder(void)
 	cl_set_cleanup(&dirent_cleanup__cb, &sub_slash);
 	setup(&sub_slash);
 
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&sub_slash.path,
 					one_entry,
 					&sub_slash));
 
@@ -171,7 +174,8 @@ static name_data empty_names[] = {
 };
 static walk_data empty = {
 	"empty",
-	empty_names
+	empty_names,
+	GIT_BUF_INIT
 };
 
 /* make sure that empty folders are not traversed */
@@ -180,16 +184,14 @@ void test_core_dirent__dont_traverse_empty_folders(void)
 	cl_set_cleanup(&dirent_cleanup__cb, &empty);
 	setup(&empty);
 
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&empty.path,
 					one_entry,
 					&empty));
 
 	check_counts(&empty);
 
 	/* make sure callback not called */
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&empty.path,
 					dont_call_me,
 					&empty));
 }
@@ -204,7 +206,8 @@ static name_data odd_names[] = {
 };
 static walk_data odd = {
 	"odd",
-	odd_names
+	odd_names,
+	GIT_BUF_INIT
 };
 
 /* make sure that strange looking filenames ('..c') are traversed */
@@ -213,10 +216,20 @@ void test_core_dirent__traverse_weird_filenames(void)
 	cl_set_cleanup(&dirent_cleanup__cb, &odd);
 	setup(&odd);
 
-	cl_git_pass(git_futils_direach(path_buffer,
-					sizeof(path_buffer),
+	cl_git_pass(git_path_direach(&odd.path,
 					one_entry,
 					&odd));
 
 	check_counts(&odd);
 }
+
+/* test filename length limits */
+void test_core_dirent__length_limits(void)
+{
+	char *big_filename = (char *)git__malloc(FILENAME_MAX + 1);
+	memset(big_filename, 'a', FILENAME_MAX + 1);
+	big_filename[FILENAME_MAX] = 0;
+
+	cl_must_fail(p_creat(big_filename, 0666));
+	git__free(big_filename);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/core/env.c

@@ -0,0 +1,115 @@
+#include "clar_libgit2.h"
+#include "fileops.h"
+#include "path.h"
+
+#ifdef GIT_WIN32
+static char *env_userprofile = NULL;
+static char *env_programfiles = NULL;
+#else
+static char *env_home = NULL;
+#endif
+
+void test_core_env__initialize(void)
+{
+#ifdef GIT_WIN32
+	env_userprofile = cl_getenv("USERPROFILE");
+	env_programfiles = cl_getenv("PROGRAMFILES");
+#else
+	env_home = cl_getenv("HOME");
+#endif
+}
+
+void test_core_env__cleanup(void)
+{
+#ifdef GIT_WIN32
+	cl_setenv("USERPROFILE", env_userprofile);
+	git__free(env_userprofile);
+	cl_setenv("PROGRAMFILES", env_programfiles);
+	git__free(env_programfiles);
+#else
+	cl_setenv("HOME", env_home);
+#endif
+}
+
+void test_core_env__0(void)
+{
+	static char *home_values[] = {
+		"fake_home",
+		"fáke_hõme", /* all in latin-1 supplement */
+		"fĀke_Ĥome", /* latin extended */
+		"fακε_hοmέ",  /* having fun with greek */
+		"faงe_นome", /* now I have no idea, but thai characters */
+		"f\xe1\x9cx80ke_\xe1\x9c\x91ome", /* tagalog characters */
+		"\xe1\xb8\x9fẢke_hoṁe", /* latin extended additional */
+		"\xf0\x9f\x98\x98\xf0\x9f\x98\x82", /* emoticons */
+		NULL
+	};
+	git_buf path = GIT_BUF_INIT, found = GIT_BUF_INIT;
+	char **val;
+	char *check;
+
+	for (val = home_values; *val != NULL; val++) {
+
+		if (p_mkdir(*val, 0777) == 0) {
+			/* if we can't make the directory, let's just assume
+			 * we are on a filesystem that doesn't support the
+			 * characters in question and skip this test...
+			 */
+			cl_git_pass(git_path_prettify(&path, *val, NULL));
+
+#ifdef GIT_WIN32
+			cl_git_pass(cl_setenv("USERPROFILE", path.ptr));
+
+			/* do a quick check that it was set correctly */
+			check = cl_getenv("USERPROFILE");
+			cl_assert_equal_s(path.ptr, check);
+			git__free(check);
+#else
+			cl_git_pass(cl_setenv("HOME", path.ptr));
+
+			/* do a quick check that it was set correctly */
+			check = cl_getenv("HOME");
+			cl_assert_equal_s(path.ptr, check);
+#endif
+
+			cl_git_pass(git_buf_puts(&path, "/testfile"));
+			cl_git_mkfile(path.ptr, "find me");
+
+			cl_git_pass(git_futils_find_global_file(&found, "testfile"));
+		}
+	}
+
+	git_buf_free(&path);
+	git_buf_free(&found);
+}
+
+void test_core_env__1(void)
+{
+	git_buf path = GIT_BUF_INIT;
+
+	cl_assert(git_futils_find_global_file(&path, "nonexistentfile") == GIT_ENOTFOUND);
+
+#ifdef GIT_WIN32
+	cl_git_pass(cl_setenv("USERPROFILE", "doesnotexist"));
+#else
+	cl_git_pass(cl_setenv("HOME", "doesnotexist"));
+#endif
+
+	cl_assert(git_futils_find_global_file(&path, "nonexistentfile") == GIT_ENOTFOUND);
+
+#ifdef GIT_WIN32
+	cl_git_pass(cl_setenv("USERPROFILE", NULL));
+#else
+	cl_git_pass(cl_setenv("HOME", NULL));
+#endif
+
+	cl_assert(git_futils_find_global_file(&path, "nonexistentfile") == -1);
+
+	cl_assert(git_futils_find_system_file(&path, "nonexistentfile") == GIT_ENOTFOUND);
+
+#ifdef GIT_WIN32
+	cl_git_pass(cl_setenv("PROGRAMFILES", NULL));
+
+	cl_assert(git_futils_find_system_file(&path, "nonexistentfile") == -1);
+#endif
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/core/errors.c

@@ -0,0 +1,60 @@
+#include "clar_libgit2.h"
+#include "common.h"
+#include "util.h"
+#include "posix.h"
+
+void test_core_errors__new_school(void)
+{
+	char *str_in_error;
+
+	giterr_clear();
+	cl_assert(giterr_last() == NULL);
+
+	giterr_set_oom(); /* internal fn */
+
+	cl_assert(giterr_last() != NULL);
+	cl_assert(giterr_last()->klass == GITERR_NOMEMORY);
+	str_in_error = strstr(giterr_last()->message, "memory");
+	cl_assert(str_in_error != NULL);
+
+	giterr_clear();
+
+	giterr_set(GITERR_REPOSITORY, "This is a test"); /* internal fn */
+
+	cl_assert(giterr_last() != NULL);
+	str_in_error = strstr(giterr_last()->message, "This is a test");
+	cl_assert(str_in_error != NULL);
+
+	giterr_clear();
+	cl_assert(giterr_last() == NULL);
+
+	do {
+		struct stat st;
+		memset(&st, 0, sizeof(st));
+		cl_assert(p_lstat("this_file_does_not_exist", &st) < 0);
+		GIT_UNUSED(st);
+	} while (false);
+	giterr_set(GITERR_OS, "stat failed"); /* internal fn */
+
+	cl_assert(giterr_last() != NULL);
+	str_in_error = strstr(giterr_last()->message, "stat failed");
+	cl_assert(str_in_error != NULL);
+	cl_assert(git__prefixcmp(str_in_error, "stat failed: ") == 0);
+	cl_assert(strlen(str_in_error) > strlen("stat failed: "));
+
+#ifdef GIT_WIN32
+	giterr_clear();
+
+	/* The MSDN docs use this to generate a sample error */
+	cl_assert(GetProcessId(NULL) == 0);
+	giterr_set(GITERR_OS, "GetProcessId failed"); /* internal fn */
+
+	cl_assert(giterr_last() != NULL);
+	str_in_error = strstr(giterr_last()->message, "GetProcessId failed");
+	cl_assert(str_in_error != NULL);
+	cl_assert(git__prefixcmp(str_in_error, "GetProcessId failed: ") == 0);
+	cl_assert(strlen(str_in_error) > strlen("GetProcessId failed: "));
+#endif
+
+	giterr_clear();
+}

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/core/filebuf.c

@@ -1,4 +1,4 @@
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 #include "filebuf.h"
 
 /* make sure git_filebuf_open doesn't delete an existing lock */
@@ -8,13 +8,13 @@ void test_core_filebuf__0(void)
 	int fd;
 	char test[] = "test", testlock[] = "test.lock";
 
-	fd = p_creat(testlock, 0744);
+	fd = p_creat(testlock, 0744); //-V536
 
 	cl_must_pass(fd);
 	cl_must_pass(p_close(fd));
 
 	cl_git_fail(git_filebuf_open(&file, test, 0));
-	cl_git_pass(git_futils_exists(testlock));
+	cl_assert(git_path_exists(testlock));
 
 	cl_must_pass(p_unlink(testlock));
 }
@@ -27,7 +27,7 @@ void test_core_filebuf__1(void)
 	int fd;
 	char test[] = "test";
 
-	fd = p_creat(test, 0666);
+	fd = p_creat(test, 0666); //-V536
 	cl_must_pass(fd);
 	cl_must_pass(p_write(fd, "libgit2 rocks\n", 14));
 	cl_must_pass(p_close(fd));
@@ -56,20 +56,6 @@ void test_core_filebuf__2(void)
 	cl_must_pass(p_unlink(test));
 }
 
-
-/* make sure git_filebuf_open won't reopen an open buffer */
-void test_core_filebuf__3(void)
-{
-	git_filebuf file = GIT_FILEBUF_INIT;
-	char test[] = "test";
-
-	cl_git_pass(git_filebuf_open(&file, test, 0));
-	cl_git_fail(git_filebuf_open(&file, test, 0));
-
-	git_filebuf_cleanup(&file);
-}
-
-
 /* make sure git_filebuf_cleanup clears the buffer */
 void test_core_filebuf__4(void)
 {

data/ext/rugged/vendor/libgit2-dist/tests-clar/core/hex.c

@@ -0,0 +1,22 @@
+#include "clar_libgit2.h"
+#include "util.h"
+
+void test_core_hex__fromhex(void)
+{
+	/* Passing cases */
+	cl_assert(git__fromhex('0') == 0x0);
+	cl_assert(git__fromhex('1') == 0x1);
+	cl_assert(git__fromhex('3') == 0x3);
+	cl_assert(git__fromhex('9') == 0x9);
+	cl_assert(git__fromhex('A') == 0xa);
+	cl_assert(git__fromhex('C') == 0xc);
+	cl_assert(git__fromhex('F') == 0xf);
+	cl_assert(git__fromhex('a') == 0xa);
+	cl_assert(git__fromhex('c') == 0xc);
+	cl_assert(git__fromhex('f') == 0xf);
+
+	/* Failing cases */
+	cl_assert(git__fromhex('g') == -1);
+	cl_assert(git__fromhex('z') == -1);
+	cl_assert(git__fromhex('X') == -1);
+}

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/core/oid.c

@@ -1,4 +1,4 @@
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 static git_oid id;
 const char *str_oid = "ae90f12eea699729ed24555e40b9fd669da12a12";
@@ -10,9 +10,9 @@ void test_core_oid__initialize(void)
 
 void test_core_oid__streq(void)
 {
-	cl_assert(git_oid_streq(&id, str_oid) == GIT_SUCCESS);
-	cl_assert(git_oid_streq(&id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") == GIT_ERROR);
+	cl_assert(git_oid_streq(&id, str_oid) == 0);
+	cl_assert(git_oid_streq(&id, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") == -1);
 
-	cl_assert(git_oid_streq(&id, "deadbeef") == GIT_ENOTOID);
-	cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == GIT_ENOTOID);
-}
+	cl_assert(git_oid_streq(&id, "deadbeef") == -1);
+	cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == -1);
+}