rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/filebuf.c

@@ -0,0 +1,106 @@
+#include "clay_libgit2.h"
+#include "filebuf.h"
+
+/* make sure git_filebuf_open doesn't delete an existing lock */
+void test_core_filebuf__0(void)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	int fd;
+	char test[] = "test", testlock[] = "test.lock";
+
+	fd = p_creat(testlock, 0744);
+
+	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_must_pass(p_unlink(testlock));
+}
+
+
+/* make sure GIT_FILEBUF_APPEND works as expected */
+void test_core_filebuf__1(void)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	int fd;
+	char test[] = "test";
+
+	fd = p_creat(test, 0666);
+	cl_must_pass(fd);
+	cl_must_pass(p_write(fd, "libgit2 rocks\n", 14));
+	cl_must_pass(p_close(fd));
+
+	cl_git_pass(git_filebuf_open(&file, test, GIT_FILEBUF_APPEND));
+	cl_git_pass(git_filebuf_printf(&file, "%s\n", "libgit2 rocks"));
+	cl_git_pass(git_filebuf_commit(&file, 0666));
+
+	cl_must_pass(p_unlink(test));
+}
+
+
+/* make sure git_filebuf_write writes large buffer correctly */
+void test_core_filebuf__2(void)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	char test[] = "test";
+	unsigned char buf[4096 * 4]; /* 2 * WRITE_BUFFER_SIZE */
+
+	memset(buf, 0xfe, sizeof(buf));
+
+	cl_git_pass(git_filebuf_open(&file, test, 0));
+	cl_git_pass(git_filebuf_write(&file, buf, sizeof(buf)));
+	cl_git_pass(git_filebuf_commit(&file, 0666));
+
+	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)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	char test[] = "test";
+
+	cl_assert(file.buffer == NULL);
+
+	cl_git_pass(git_filebuf_open(&file, test, 0));
+	cl_assert(file.buffer != NULL);
+
+	git_filebuf_cleanup(&file);
+	cl_assert(file.buffer == NULL);
+}
+
+
+/* make sure git_filebuf_commit clears the buffer */
+void test_core_filebuf__5(void)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	char test[] = "test";
+
+	cl_assert(file.buffer == NULL);
+
+	cl_git_pass(git_filebuf_open(&file, test, 0));
+	cl_assert(file.buffer != NULL);
+	cl_git_pass(git_filebuf_printf(&file, "%s\n", "libgit2 rocks"));
+	cl_assert(file.buffer != NULL);
+
+	cl_git_pass(git_filebuf_commit(&file, 0666));
+	cl_assert(file.buffer == NULL);
+
+	cl_must_pass(p_unlink(test));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/oid.c

@@ -0,0 +1,18 @@
+#include "clay_libgit2.h"
+
+static git_oid id;
+const char *str_oid = "ae90f12eea699729ed24555e40b9fd669da12a12";
+
+void test_core_oid__initialize(void)
+{
+	cl_git_pass(git_oid_fromstr(&id, str_oid));
+}
+
+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, "deadbeef") == GIT_ENOTOID);
+	cl_assert(git_oid_streq(&id, "I'm not an oid.... :)") == GIT_ENOTOID);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/path.c

@@ -0,0 +1,139 @@
+#include "clay_libgit2.h"
+#include <fileops.h>
+
+static void
+check_dirname(const char *A, const char *B)
+{
+	char dir[64], *dir2;
+
+	cl_assert(git_path_dirname_r(dir, sizeof(dir), A) >= 0);
+	cl_assert(strcmp(dir, B) == 0);
+	cl_assert((dir2 = git_path_dirname(A)) != NULL);
+	cl_assert(strcmp(dir2, B) == 0);
+
+	git__free(dir2);
+}
+
+static void
+check_basename(const char *A, const char *B)
+{
+	char base[64], *base2;
+
+	cl_assert(git_path_basename_r(base, sizeof(base), A) >= 0);
+	cl_assert(strcmp(base, B) == 0);
+	cl_assert((base2 = git_path_basename(A)) != NULL);
+	cl_assert(strcmp(base2, B) == 0);
+
+	git__free(base2);
+}
+
+static void
+check_topdir(const char *A, const char *B)
+{
+	const char *dir;
+
+	cl_assert((dir = git_path_topdir(A)) != NULL);
+	cl_assert(strcmp(dir, B) == 0);
+}
+
+static void
+check_joinpath(const char *path_a, const char *path_b, const char *expected_path)
+{
+	char joined_path[GIT_PATH_MAX];
+
+	git_path_join(joined_path, path_a, path_b);
+	cl_assert(strcmp(joined_path, expected_path) == 0);
+}
+
+static void
+check_joinpath_n(
+	const char *path_a,
+	const char *path_b,
+	const char *path_c,
+	const char *path_d,
+	const char *expected_path)
+{
+	char joined_path[GIT_PATH_MAX];
+
+	git_path_join_n(joined_path, 4, path_a, path_b, path_c, path_d);
+	cl_assert(strcmp(joined_path, expected_path) == 0);
+}
+
+
+/* get the dirname of a path */
+void test_core_path__0(void)
+{
+
+	check_dirname(NULL, ".");
+	check_dirname("", ".");
+	check_dirname("a", ".");
+	check_dirname("/", "/");
+	check_dirname("/usr", "/");
+	check_dirname("/usr/", "/");
+	check_dirname("/usr/lib", "/usr");
+	check_dirname("/usr/lib/", "/usr");
+	check_dirname("/usr/lib//", "/usr");
+	check_dirname("usr/lib", "usr");
+	check_dirname("usr/lib/", "usr");
+	check_dirname("usr/lib//", "usr");
+	check_dirname(".git/", ".");
+}
+
+/* get the base name of a path */
+void test_core_path__1(void)
+{
+	check_basename(NULL, ".");
+	check_basename("", ".");
+	check_basename("a", "a");
+	check_basename("/", "/");
+	check_basename("/usr", "usr");
+	check_basename("/usr/", "usr");
+	check_basename("/usr/lib", "lib");
+	check_basename("/usr/lib//", "lib");
+	check_basename("usr/lib", "lib");
+}
+
+/* get the latest component in a path */
+void test_core_path__2(void)
+{
+	check_topdir(".git/", ".git/");
+	check_topdir("/.git/", ".git/");
+	check_topdir("usr/local/.git/", ".git/");
+	check_topdir("./.git/", ".git/");
+	check_topdir("/usr/.git/", ".git/");
+	check_topdir("/", "/");
+	check_topdir("a/", "a/");
+
+	cl_assert(git_path_topdir("/usr/.git") == NULL);
+	cl_assert(git_path_topdir(".") == NULL);
+	cl_assert(git_path_topdir("") == NULL);
+	cl_assert(git_path_topdir("a") == NULL);
+}
+
+/* properly join path components */
+void test_core_path__5(void)
+{
+	check_joinpath("", "", "");
+	check_joinpath("", "a", "a");
+	check_joinpath("", "/a", "/a");
+	check_joinpath("a", "", "a/");
+	check_joinpath("a", "/", "a/");
+	check_joinpath("a", "b", "a/b");
+	check_joinpath("/", "a", "/a");
+	check_joinpath("/", "", "/");
+	check_joinpath("/a", "/b", "/a/b");
+	check_joinpath("/a", "/b/", "/a/b/");
+	check_joinpath("/a/", "b/", "/a/b/");
+	check_joinpath("/a/", "/b/", "/a/b/");
+}
+
+/* properly join path components for more than one path */
+void test_core_path__6(void)
+{
+	check_joinpath_n("", "", "", "", "");
+	check_joinpath_n("", "a", "", "", "a/");
+	check_joinpath_n("a", "", "", "", "a/");
+	check_joinpath_n("", "", "", "a", "a");
+	check_joinpath_n("a", "b", "", "/c/d/", "a/b/c/d/");
+	check_joinpath_n("a", "b", "", "/c/d", "a/b/c/d");
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/rmdir.c

@@ -0,0 +1,50 @@
+#include "clay_libgit2.h"
+#include "fileops.h"
+
+static const char *empty_tmp_dir = "test_gitfo_rmdir_recurs_test";
+
+void test_core_rmdir__initialize(void)
+{
+	char path[GIT_PATH_MAX];
+
+	cl_must_pass(p_mkdir(empty_tmp_dir, 0777));
+
+	git_path_join(path, empty_tmp_dir, "/one");
+	cl_must_pass(p_mkdir(path, 0777));
+
+	git_path_join(path, empty_tmp_dir, "/one/two_one");
+	cl_must_pass(p_mkdir(path, 0777));
+
+	git_path_join(path, empty_tmp_dir, "/one/two_two");
+	cl_must_pass(p_mkdir(path, 0777));
+
+	git_path_join(path, empty_tmp_dir, "/one/two_two/three");
+	cl_must_pass(p_mkdir(path, 0777));
+
+	git_path_join(path, empty_tmp_dir, "/two");
+	cl_must_pass(p_mkdir(path, 0777));
+}
+
+/* make sure empty dir can be deleted recusively */
+void test_core_rmdir__delete_recursive(void)
+{
+	cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, 0));
+}
+
+/* make sure non-empty dir cannot be deleted recusively */
+void test_core_rmdir__fail_to_delete_non_empty_dir(void)
+{
+	char file[GIT_PATH_MAX];
+	int fd;
+
+	git_path_join(file, empty_tmp_dir, "/two/file.txt");
+
+	fd = p_creat(file, 0666);
+	cl_assert(fd >= 0);
+
+	cl_must_pass(p_close(fd));
+	cl_git_fail(git_futils_rmdir_r(empty_tmp_dir, 0));
+
+	cl_must_pass(p_unlink(file));
+	cl_git_pass(git_futils_rmdir_r(empty_tmp_dir, 0));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/string.c

@@ -0,0 +1,28 @@
+#include "clay_libgit2.h"
+
+/* compare prefixes */
+void test_core_string__0(void)
+{
+	cl_assert(git__prefixcmp("", "") == 0);
+	cl_assert(git__prefixcmp("a", "") == 0);
+	cl_assert(git__prefixcmp("", "a") < 0);
+	cl_assert(git__prefixcmp("a", "b") < 0);
+	cl_assert(git__prefixcmp("b", "a") > 0);
+	cl_assert(git__prefixcmp("ab", "a") == 0);
+	cl_assert(git__prefixcmp("ab", "ac") < 0);
+	cl_assert(git__prefixcmp("ab", "aa") > 0);
+}
+
+/* compare suffixes */
+void test_core_string__1(void)
+{
+	cl_assert(git__suffixcmp("", "") == 0);
+	cl_assert(git__suffixcmp("a", "") == 0);
+	cl_assert(git__suffixcmp("", "a") < 0);
+	cl_assert(git__suffixcmp("a", "b") < 0);
+	cl_assert(git__suffixcmp("b", "a") > 0);
+	cl_assert(git__suffixcmp("ba", "a") == 0);
+	cl_assert(git__suffixcmp("zaa", "ac") < 0);
+	cl_assert(git__suffixcmp("zaz", "ac") > 0);
+}
+

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/strtol.c

@@ -0,0 +1,37 @@
+#include "clay_libgit2.h"
+
+void test_core_strtol__int32(void)
+{
+	int32_t i;
+
+	cl_git_pass(git__strtol32(&i, "123", NULL, 10));
+	cl_assert(i == 123);
+	cl_git_pass(git__strtol32(&i, "  +123 ", NULL, 10));
+	cl_assert(i == 123);
+	cl_git_pass(git__strtol32(&i, "  +2147483647 ", NULL, 10));
+	cl_assert(i == 2147483647);
+	cl_git_pass(git__strtol32(&i, "  -2147483648 ", NULL, 10));
+	cl_assert(i == -2147483648LL);
+	
+	cl_git_fail(git__strtol32(&i, "  2147483657 ", NULL, 10));
+	cl_git_fail(git__strtol32(&i, "  -2147483657 ", NULL, 10));
+}
+
+void test_core_strtol__int64(void)
+{
+	int64_t i;
+
+	cl_git_pass(git__strtol64(&i, "123", NULL, 10));
+	cl_assert(i == 123);
+	cl_git_pass(git__strtol64(&i, "  +123 ", NULL, 10));
+	cl_assert(i == 123);
+	cl_git_pass(git__strtol64(&i, "  +2147483647 ", NULL, 10));
+	cl_assert(i == 2147483647);
+	cl_git_pass(git__strtol64(&i, "  -2147483648 ", NULL, 10));
+	cl_assert(i == -2147483648LL);
+	cl_git_pass(git__strtol64(&i, "  2147483657 ", NULL, 10));
+	cl_assert(i == 2147483657LL);
+	cl_git_pass(git__strtol64(&i, "  -2147483657 ", NULL, 10));
+	cl_assert(i == -2147483657LL);
+}
+

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/vector.c

@@ -0,0 +1,66 @@
+#include "clay_libgit2.h"
+#include "vector.h"
+
+/* initial size of 1 would cause writing past array bounds */
+void test_core_vector__0(void)
+{
+	git_vector x;
+	int i;
+	git_vector_init(&x, 1, NULL);
+	for (i = 0; i < 10; ++i) {
+		git_vector_insert(&x, (void*) 0xabc);
+	}
+	git_vector_free(&x);
+}
+
+
+/* don't read past array bounds on remove() */
+void test_core_vector__1(void)
+{
+	git_vector x;
+	// make initial capacity exact for our insertions.
+	git_vector_init(&x, 3, NULL);
+	git_vector_insert(&x, (void*) 0xabc);
+	git_vector_insert(&x, (void*) 0xdef);
+	git_vector_insert(&x, (void*) 0x123);
+
+	git_vector_remove(&x, 0); // used to read past array bounds.
+	git_vector_free(&x);
+}
+
+
+static int test_cmp(const void *a, const void *b)
+{
+	return *(const int *)a - *(const int *)b;
+}
+
+/* remove duplicates */
+void test_core_vector__2(void)
+{
+	git_vector x;
+	int *ptrs[2];
+
+	ptrs[0] = git__malloc(sizeof(int));
+	ptrs[1] = git__malloc(sizeof(int));
+
+	*ptrs[0] = 2;
+	*ptrs[1] = 1;
+
+	cl_git_pass(git_vector_init(&x, 5, test_cmp));
+	cl_git_pass(git_vector_insert(&x, ptrs[0]));
+	cl_git_pass(git_vector_insert(&x, ptrs[1]));
+	cl_git_pass(git_vector_insert(&x, ptrs[1]));
+	cl_git_pass(git_vector_insert(&x, ptrs[0]));
+	cl_git_pass(git_vector_insert(&x, ptrs[1]));
+	cl_assert(x.length == 5);
+
+	git_vector_uniq(&x);
+	cl_assert(x.length == 2);
+
+	git_vector_free(&x);
+
+	git__free(ptrs[0]);
+	git__free(ptrs[1]);
+}
+
+