rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/tests/test_helpers.c

@@ -0,0 +1,310 @@
+/*
+ * 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 "common.h"
+#include "test_helpers.h"
+#include "fileops.h"
+
+int write_object_data(char *file, void *data, size_t len)
+{
+	git_file fd;
+	int ret;
+
+	if ((fd = p_creat(file, S_IREAD | S_IWRITE)) < 0)
+		return -1;
+	ret = p_write(fd, data, len);
+	p_close(fd);
+
+	return ret;
+}
+
+int write_object_files(const char *odb_dir, object_data *d)
+{
+	if (p_mkdir(odb_dir, GIT_OBJECT_DIR_MODE) < 0) {
+		int err = errno;
+		fprintf(stderr, "can't make directory \"%s\"", odb_dir);
+		if (err == EEXIST)
+			fprintf(stderr, " (already exists)");
+		fprintf(stderr, "\n");
+		return -1;
+	}
+
+	if ((p_mkdir(d->dir, GIT_OBJECT_DIR_MODE) < 0) && (errno != EEXIST)) {
+		fprintf(stderr, "can't make object directory \"%s\"\n", d->dir);
+		return -1;
+	}
+	if (write_object_data(d->file, d->bytes, d->blen) < 0) {
+		fprintf(stderr, "can't write object file \"%s\"\n", d->file);
+		return -1;
+	}
+
+	return 0;
+}
+
+int remove_object_files(const char *odb_dir, object_data *d)
+{
+	if (p_unlink(d->file) < 0) {
+		fprintf(stderr, "can't delete object file \"%s\"\n", d->file);
+		return -1;
+	}
+	if ((p_rmdir(d->dir) < 0) && (errno != ENOTEMPTY)) {
+		fprintf(stderr, "can't remove object directory \"%s\"\n", d->dir);
+		return -1;
+	}
+
+	if (p_rmdir(odb_dir) < 0) {
+		fprintf(stderr, "can't remove directory \"%s\"\n", odb_dir);
+		return -1;
+	}
+
+	return 0;
+}
+
+void locate_loose_object(const char *repository_folder, git_object *object, char **out, char **out_folder)
+{
+	static const char *objects_folder = "objects/";
+
+	char *ptr, *full_path, *top_folder;
+	int path_length, objects_length;
+
+	assert(repository_folder && object);
+
+	objects_length = strlen(objects_folder);
+	path_length = strlen(repository_folder);
+	ptr = full_path = git__malloc(path_length + objects_length + GIT_OID_HEXSZ + 3);
+
+	strcpy(ptr, repository_folder);
+	strcpy(ptr + path_length, objects_folder);
+
+	ptr = top_folder = ptr + path_length + objects_length;
+	*ptr++ = '/';
+	git_oid_pathfmt(ptr, git_object_id(object));
+	ptr += GIT_OID_HEXSZ + 1;
+	*ptr = 0;
+
+	*out = full_path;
+
+	if (out_folder)
+		*out_folder = top_folder;
+}
+
+int loose_object_mode(const char *repository_folder, git_object *object)
+{
+	char *object_path;
+	struct stat st;
+
+	locate_loose_object(repository_folder, object, &object_path, NULL);
+	if (p_stat(object_path, &st) < 0)
+		return 0;
+	free(object_path);
+
+	return st.st_mode;
+}
+
+int loose_object_dir_mode(const char *repository_folder, git_object *object)
+{
+	char *object_path;
+	size_t pos;
+	struct stat st;
+
+	locate_loose_object(repository_folder, object, &object_path, NULL);
+
+	pos = strlen(object_path);
+	while (pos--) {
+		if (object_path[pos] == '/') {
+			object_path[pos] = 0;
+			break;
+		}
+	}
+
+	if (p_stat(object_path, &st) < 0)
+		return 0;
+	free(object_path);
+
+	return st.st_mode;
+}
+
+int remove_loose_object(const char *repository_folder, git_object *object)
+{
+	char *full_path, *top_folder;
+
+	locate_loose_object(repository_folder, object, &full_path, &top_folder);
+
+	if (p_unlink(full_path) < 0) {
+		fprintf(stderr, "can't delete object file \"%s\"\n", full_path);
+		return -1;
+	}
+
+	*top_folder = 0;
+
+	if ((p_rmdir(full_path) < 0) && (errno != ENOTEMPTY)) {
+		fprintf(stderr, "can't remove object directory \"%s\"\n", full_path);
+		return -1;
+	}
+
+	git__free(full_path);
+
+	return GIT_SUCCESS;
+}
+
+int cmp_objects(git_rawobj *o, object_data *d)
+{
+	if (o->type != git_object_string2type(d->type))
+		return -1;
+	if (o->len != d->dlen)
+		return -1;
+	if ((o->len > 0) && (memcmp(o->data, d->data, o->len) != 0))
+		return -1;
+	return 0;
+}
+
+int copy_file(const char *src, const char *dst)
+{
+	git_fbuffer source_buf;
+	git_file dst_fd;
+	int error = GIT_ERROR;
+
+	if (git_futils_readbuffer(&source_buf, src) < GIT_SUCCESS)
+		return GIT_ENOTFOUND;
+
+	dst_fd = git_futils_creat_withpath(dst, 0777, 0666);
+	if (dst_fd < 0)
+		goto cleanup;
+
+	error = p_write(dst_fd, source_buf.data, source_buf.len);
+
+cleanup:
+	git_futils_freebuffer(&source_buf);
+	p_close(dst_fd);
+
+	return error;
+}
+
+int cmp_files(const char *a, const char *b)
+{
+	git_fbuffer buf_a, buf_b;
+	int error = GIT_ERROR;
+
+	if (git_futils_readbuffer(&buf_a, a) < GIT_SUCCESS)
+		return GIT_ERROR;
+
+	if (git_futils_readbuffer(&buf_b, b) < GIT_SUCCESS) {
+		git_futils_freebuffer(&buf_a);
+		return GIT_ERROR;
+	}
+
+	if (buf_a.len == buf_b.len && !memcmp(buf_a.data, buf_b.data, buf_a.len))
+		error = GIT_SUCCESS;
+
+	git_futils_freebuffer(&buf_a);
+	git_futils_freebuffer(&buf_b);
+
+	return error;
+}
+
+typedef struct {
+	size_t src_len, dst_len;
+	char *dst;
+} copydir_data;
+
+static int copy_filesystem_element_recurs(void *_data, char *source)
+{
+	copydir_data *data = (copydir_data *)_data;
+
+	data->dst[data->dst_len] = 0;
+	git_path_join(data->dst, data->dst, source + data->src_len);
+
+	if (git_futils_isdir(source) == GIT_SUCCESS)
+		return git_futils_direach(source, GIT_PATH_MAX, copy_filesystem_element_recurs, _data);
+
+	return copy_file(source, data->dst);
+}
+
+int copydir_recurs(const char *source_directory_path, const char *destination_directory_path)
+{
+	char source_buffer[GIT_PATH_MAX];
+	char dest_buffer[GIT_PATH_MAX];
+	copydir_data data;
+
+	/* Source has to exist, Destination hast to _not_ exist */
+	if (git_futils_isdir(source_directory_path) != GIT_SUCCESS ||
+		git_futils_isdir(destination_directory_path) == GIT_SUCCESS)
+		return GIT_EINVALIDPATH;
+
+	git_path_join(source_buffer, source_directory_path, "");
+	data.src_len = strlen(source_buffer);
+
+	git_path_join(dest_buffer, destination_directory_path, "");
+	data.dst = dest_buffer;
+	data.dst_len = strlen(dest_buffer);
+
+	return copy_filesystem_element_recurs(&data, source_buffer);
+}
+
+int open_temp_repo(git_repository **repo, const char *path)
+{
+	int error;
+	if ((error = copydir_recurs(path, TEMP_REPO_FOLDER)) < GIT_SUCCESS)
+		return error;
+
+	return git_repository_open(repo, TEMP_REPO_FOLDER);
+}
+
+void close_temp_repo(git_repository *repo)
+{
+	git_repository_free(repo);
+	if (git_futils_rmdir_r(TEMP_REPO_FOLDER, 1) < GIT_SUCCESS) {
+		printf("\nFailed to remove temporary folder. Aborting test suite.\n");
+		exit(-1);
+	}
+}
+
+static int remove_placeholders_recurs(void *filename, char *path)
+{
+	char passed_filename[GIT_PATH_MAX];
+	char *data = (char *)filename;
+
+	if (!git_futils_isdir(path))
+		return git_futils_direach(path, GIT_PATH_MAX, remove_placeholders_recurs, data);
+
+	if (git_path_basename_r(passed_filename, sizeof(passed_filename), path) < GIT_SUCCESS)
+		return GIT_EINVALIDPATH;
+
+	if (!strcmp(data, passed_filename))
+		return p_unlink(path);
+
+	return GIT_SUCCESS;
+}
+
+int remove_placeholders(char *directory_path, char *filename)
+{
+	char buffer[GIT_PATH_MAX];
+
+	if (git_futils_isdir(directory_path))
+		return GIT_EINVALIDPATH;
+
+	strcpy(buffer, directory_path);
+	return remove_placeholders_recurs(filename, buffer);
+}

data/ext/rugged/vendor/libgit2-dist/tests/test_helpers.h

@@ -0,0 +1,83 @@
+/*
+ * 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.
+ */
+
+#ifndef INCLUDE_test_helpers_h__
+#define INCLUDE_test_helpers_h__
+
+#include "test_lib.h"
+#include <git2.h>
+
+#include "odb.h"
+
+#define TEST_REPOSITORY_NAME	"testrepo.git"
+#define REPOSITORY_FOLDER		TEST_RESOURCES "/" TEST_REPOSITORY_NAME "/"
+#define ODB_FOLDER				(REPOSITORY_FOLDER "objects/")
+#define TEST_INDEX_PATH			(REPOSITORY_FOLDER "index")
+#define TEST_INDEX2_PATH		(TEST_RESOURCES "/gitgit.index")
+#define TEST_INDEXBIG_PATH		(TEST_RESOURCES "/big.index")
+#define EMPTY_REPOSITORY_FOLDER	TEST_RESOURCES "/empty_standard_repo/.gitted/"
+
+#define TEMP_FOLDER				""
+#define TEMP_REPO_FOLDER		TEMP_FOLDER TEST_REPOSITORY_NAME "/"
+#define TEMP_REPO_FOLDER_NS		TEMP_FOLDER TEST_REPOSITORY_NAME
+#define TEST_STD_REPO_FOLDER	TEMP_REPO_FOLDER ".git/"
+
+typedef struct object_data {
+    unsigned char *bytes;  /* (compressed) bytes stored in object store */
+    size_t        blen;    /* length of data in object store            */
+    char          *id;     /* object id (sha1)                          */
+    char          *type;   /* object type                               */
+    char          *dir;    /* object store (fan-out) directory name     */
+    char          *file;   /* object store filename                     */
+    unsigned char *data;   /* (uncompressed) object data                */
+    size_t        dlen;    /* length of (uncompressed) object data      */
+} object_data;
+
+extern int write_object_data(char *file, void *data, size_t len);
+
+extern int write_object_files(const char *odb_dir, object_data *d);
+
+extern int remove_object_files(const char *odb_dir, object_data *d);
+
+extern int cmp_objects(git_rawobj *o, object_data *d);
+
+extern void locate_loose_object(const char *odb_dir, git_object *object, char **out, char **out_folder);
+
+extern int loose_object_mode(const char *odb_dir, git_object *object);
+extern int loose_object_dir_mode(const char *odb_dir, git_object *object);
+
+extern int remove_loose_object(const char *odb_dir, git_object *object);
+
+extern int cmp_files(const char *a, const char *b);
+extern int copy_file(const char *source, const char *dest);
+extern int rmdir_recurs(const char *directory_path);
+extern int copydir_recurs(const char *source_directory_path, const char *destination_directory_path);
+extern int remove_placeholders(char *directory_path, char *filename);
+
+extern int open_temp_repo(git_repository **repo, const char *path);
+extern void close_temp_repo(git_repository *repo);
+
+#endif
+/* INCLUDE_test_helpers_h__ */

data/ext/rugged/vendor/libgit2-dist/tests/test_lib.c

@@ -0,0 +1,198 @@
+#include <assert.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "test_lib.h"
+
+#define DO_ALLOC(TYPE) ((TYPE*) malloc(sizeof(TYPE)))
+#define GIT_MAX_TEST_CASES 64
+
+struct git_test {
+	char *name;
+	char *message;
+	char *failed_pos;
+	char *description;
+	char *error_message;
+
+	git_testfunc function;
+	unsigned failed:1, ran:1;
+	jmp_buf *jump;
+};
+
+struct git_testsuite {
+	char *name;
+	int count, fail_count;
+	git_test *list[GIT_MAX_TEST_CASES];
+};
+
+static void test_free(git_test *t)
+{
+	if (t) {
+		free(t->name);
+		free(t->description);
+		free(t->failed_pos);
+		free(t->message);
+		free(t->error_message);
+		free(t);
+	}
+}
+
+static void test_run(git_test *tc)
+{
+	jmp_buf buf;
+	tc->jump = &buf;
+
+	if (setjmp(buf) == 0) {
+		tc->ran = 1;
+		(tc->function)(tc);
+	}
+
+	tc->jump = 0;
+}
+
+static git_test *create_test(git_testfunc function)
+{
+	git_test *t = DO_ALLOC(git_test);
+
+	memset(t, 0x0, sizeof(git_test));
+	t->function = function;
+
+	return t;
+}
+
+void git_test__init(git_test *t, const char *name, const char *description)
+{
+	t->name = strdup(name);
+	t->description = strdup(description);
+}
+
+
+/*-------------------------------------------------------------------------*
+ * Public assert methods
+ *-------------------------------------------------------------------------*/
+
+static void fail_test(git_test *tc, const char *file, int line, const char *message)
+{
+	char buf[1024];
+	const char *last_error = git_lasterror();
+
+	snprintf(buf, 1024, "%s:%d", file, line);
+
+	tc->failed = 1;
+	tc->message = strdup(message);
+	tc->failed_pos = strdup(buf);
+
+	if (last_error)
+		tc->error_message = strdup(last_error);
+
+	if (tc->jump != 0)
+		longjmp(*(tc->jump), 0);
+}
+
+void git_test__fail(git_test *tc, const char *file, int line, const char *message)
+{
+	fail_test(tc, file, line, message);
+}
+
+void git_test__assert(git_test *tc, const char *file, int line, const char *message, int condition)
+{
+	if (condition == 0)
+		fail_test(tc, file, line, message);
+}
+
+void git_test__assert_pass(git_test *tc, const char *file, int line, const char *message, int ret_value)
+{
+	if (ret_value < 0)
+		fail_test(tc, file, line, message);
+}
+
+/*-------------------------------------------------------------------------*
+ * Test Suite
+ *-------------------------------------------------------------------------*/
+
+static void testsuite_init(git_testsuite *ts)
+{
+	ts->count = 0;
+	ts->fail_count = 0;
+	memset(ts->list, 0, sizeof(ts->list));
+}
+
+git_testsuite *git_testsuite_new(const char *name)
+{
+	git_testsuite *ts = DO_ALLOC(git_testsuite);
+	testsuite_init(ts);
+	ts->name = strdup(name);
+	return ts;
+}
+
+static void free_suite(git_testsuite *ts)
+{
+	unsigned int n;
+
+	for (n = 0; n < GIT_MAX_TEST_CASES; n++)
+		if (ts->list[n])
+			test_free(ts->list[n]);
+
+	free(ts->name);
+	free(ts);
+}
+
+void git_testsuite_add(git_testsuite *ts, git_testfunc test)
+{
+	assert(ts->count < GIT_MAX_TEST_CASES);
+	ts->list[ts->count++] = create_test(test);
+}
+
+static void print_details(git_testsuite *ts)
+{
+	int i;
+	int failCount = 0;
+
+	if (ts->fail_count == 0) {
+		const char *testWord = ts->count == 1 ? "test" : "tests";
+		printf("OK (%d %s)\n", ts->count, testWord);
+	} else {
+		printf("Failed (%d failures):\n", ts->fail_count);
+
+		for (i = 0 ; i < ts->count ; ++i) {
+			git_test *tc = ts->list[i];
+			if (tc->failed) {
+				failCount++;
+				printf("  %d) \"%s\" [test %s @ %s]\n\t%s\n",
+					failCount, tc->description, tc->name, tc->failed_pos, tc->message);
+				if (tc->error_message)
+					printf("\tError: %s\n", tc->error_message);
+			}
+		}
+	}
+}
+
+int git_testsuite_run(git_testsuite *ts)
+{
+	int i, fail_count;
+
+	printf("Suite \"%s\": ", ts->name);
+
+	for (i = 0 ; i < ts->count ; ++i) {
+		git_test *tc = ts->list[i];
+
+		test_run(tc);
+		if (tc->failed) {
+			ts->fail_count++;
+			putchar('F');
+		} else
+			putchar('.');
+
+		fflush(stdout);
+	}
+	printf("\n  ");
+	print_details(ts);
+	fail_count = ts->fail_count;
+
+	free_suite(ts);
+	return fail_count;
+}
+