rugged 0.16.0 → 0.17.0b1

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

@@ -0,0 +1,191 @@
+#include "clar_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]);
+}
+
+
+static int compare_them(const void *a, const void *b)
+{
+	return (int)((long)a - (long)b);
+}
+
+/* insert_sorted */
+void test_core_vector__3(void)
+{
+	git_vector x;
+	long i;
+	git_vector_init(&x, 1, &compare_them);
+
+	for (i = 0; i < 10; i += 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	for (i = 9; i > 0; i -= 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	cl_assert(x.length == 10);
+	for (i = 0; i < 10; ++i) {
+		cl_assert(git_vector_get(&x, i) == (void*)(i + 1));
+	}
+
+	git_vector_free(&x);
+}
+
+/* insert_sorted with duplicates */
+void test_core_vector__4(void)
+{
+	git_vector x;
+	long i;
+	git_vector_init(&x, 1, &compare_them);
+
+	for (i = 0; i < 10; i += 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	for (i = 9; i > 0; i -= 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	for (i = 0; i < 10; i += 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	for (i = 9; i > 0; i -= 2) {
+		git_vector_insert_sorted(&x, (void*)(i + 1), NULL);
+	}
+
+	cl_assert(x.length == 20);
+	for (i = 0; i < 20; ++i) {
+		cl_assert(git_vector_get(&x, i) == (void*)(i / 2 + 1));
+	}
+
+	git_vector_free(&x);
+}
+
+typedef struct {
+	int content;
+	int count;
+} my_struct;
+
+static int _struct_count = 0;
+
+static int compare_structs(const void *a, const void *b)
+{
+	return ((const my_struct *)a)->content -
+		((const my_struct *)b)->content;
+}
+
+static int merge_structs(void **old_raw, void *new)
+{
+	my_struct *old = *(my_struct **)old_raw;
+	cl_assert(((my_struct *)old)->content == ((my_struct *)new)->content);
+	((my_struct *)old)->count += 1;
+	git__free(new);
+	_struct_count--;
+	return GIT_EEXISTS;
+}
+
+static my_struct *alloc_struct(int value)
+{
+	my_struct *st = git__malloc(sizeof(my_struct));
+	st->content = value;
+	st->count = 0;
+	_struct_count++;
+	return st;
+}
+
+/* insert_sorted with duplicates and special handling */
+void test_core_vector__5(void)
+{
+	git_vector x;
+	int i;
+
+	git_vector_init(&x, 1, &compare_structs);
+
+	for (i = 0; i < 10; i += 2)
+		git_vector_insert_sorted(&x, alloc_struct(i), &merge_structs);
+
+	for (i = 9; i > 0; i -= 2)
+		git_vector_insert_sorted(&x, alloc_struct(i), &merge_structs);
+
+	cl_assert(x.length == 10);
+	cl_assert(_struct_count == 10);
+
+	for (i = 0; i < 10; i += 2)
+		git_vector_insert_sorted(&x, alloc_struct(i), &merge_structs);
+
+	for (i = 9; i > 0; i -= 2)
+		git_vector_insert_sorted(&x, alloc_struct(i), &merge_structs);
+
+	cl_assert(x.length == 10);
+	cl_assert(_struct_count == 10);
+
+	for (i = 0; i < 10; ++i) {
+		cl_assert(((my_struct *)git_vector_get(&x, i))->content == i);
+		git__free(git_vector_get(&x, i));
+		_struct_count--;
+	}
+
+	git_vector_free(&x);
+}

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

@@ -0,0 +1,15 @@
+#include "clar_libgit2.h"
+
+#include "util.h"
+
+void test_date_date__overflow(void)
+{
+#ifdef __LP64__
+   git_time_t d2038, d2039;
+
+   /* This is expected to fail on a 32-bit machine. */
+   cl_git_pass(git__date_parse(&d2038, "2038-1-1"));
+   cl_git_pass(git__date_parse(&d2039, "2039-1-1"));
+   cl_assert(d2038 < d2039);
+#endif
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/diff/blob.c

@@ -0,0 +1,254 @@
+#include "clar_libgit2.h"
+#include "diff_helpers.h"
+
+static git_repository *g_repo = NULL;
+static diff_expects expected;
+static git_diff_options opts;
+static git_blob *d, *alien;
+
+void test_diff_blob__initialize(void)
+{
+	git_oid oid;
+
+	g_repo = cl_git_sandbox_init("attr");
+
+	memset(&opts, 0, sizeof(opts));
+	opts.context_lines = 1;
+	opts.interhunk_lines = 1;
+
+	memset(&expected, 0, sizeof(expected));
+
+	/* tests/resources/attr/root_test4.txt */
+	cl_git_pass(git_oid_fromstrn(&oid, "fe773770c5a6", 12));
+	cl_git_pass(git_blob_lookup_prefix(&d, g_repo, &oid, 6));
+
+	/* alien.png */
+	cl_git_pass(git_oid_fromstrn(&oid, "edf3dcee", 8));
+	cl_git_pass(git_blob_lookup_prefix(&alien, g_repo, &oid, 4));
+}
+
+void test_diff_blob__cleanup(void)
+{
+	git_blob_free(d);
+	git_blob_free(alien);
+
+	cl_git_sandbox_cleanup();
+}
+
+void test_diff_blob__can_compare_text_blobs(void)
+{
+	git_blob *a, *b, *c;
+	git_oid a_oid, b_oid, c_oid;
+
+	/* tests/resources/attr/root_test1 */
+	cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
+	cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
+
+	/* tests/resources/attr/root_test2 */
+	cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8));
+	cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4));
+
+	/* tests/resources/attr/root_test3 */
+	cl_git_pass(git_oid_fromstrn(&c_oid, "c96bbb2c2557a832", 16));
+	cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 8));
+
+	/* Doing the equivalent of a `git diff -U1` on these files */
+
+	cl_git_pass(git_diff_blobs(
+		a, b, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_mods == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 1);
+	cl_assert(expected.lines == 6);
+	cl_assert(expected.line_ctxt == 1);
+	cl_assert(expected.line_adds == 5);
+	cl_assert(expected.line_dels == 0);
+
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_blobs(
+		b, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_mods == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 1);
+	cl_assert(expected.lines == 15);
+	cl_assert(expected.line_ctxt == 3);
+	cl_assert(expected.line_adds == 9);
+	cl_assert(expected.line_dels == 3);
+
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_blobs(
+		a, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_mods == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 1);
+	cl_assert(expected.lines == 13);
+	cl_assert(expected.line_ctxt == 0);
+	cl_assert(expected.line_adds == 12);
+	cl_assert(expected.line_dels == 1);
+
+	opts.context_lines = 1;
+
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_blobs(
+		c, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_mods == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 2);
+	cl_assert(expected.lines == 14);
+	cl_assert(expected.line_ctxt == 4);
+	cl_assert(expected.line_adds == 6);
+	cl_assert(expected.line_dels == 4);
+
+	git_blob_free(a);
+	git_blob_free(b);
+	git_blob_free(c);
+}
+
+void test_diff_blob__can_compare_against_null_blobs(void)
+{
+	git_blob *e = NULL;
+
+	cl_git_pass(git_diff_blobs(
+		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_dels == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 1);
+	cl_assert(expected.hunk_old_lines == 14);
+	cl_assert(expected.lines == 14);
+	cl_assert(expected.line_dels == 14);
+
+	opts.flags |= GIT_DIFF_REVERSE;
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_blobs(
+		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_adds == 1);
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+
+	cl_assert(expected.hunks == 1);
+	cl_assert(expected.hunk_new_lines == 14);
+	cl_assert(expected.lines == 14);
+	cl_assert(expected.line_adds == 14);
+
+	opts.flags ^= GIT_DIFF_REVERSE;
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_blobs(
+		alien, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.at_least_one_of_them_is_binary == true);
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_dels == 1);
+	cl_assert(expected.hunks == 0);
+	cl_assert(expected.lines == 0);
+
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_blobs(
+		NULL, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.at_least_one_of_them_is_binary == true);
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_adds == 1);
+	cl_assert(expected.hunks == 0);
+	cl_assert(expected.lines == 0);
+}
+
+static void assert_identical_blobs_comparison(diff_expects expected)
+{
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_unmodified == 1);
+	cl_assert(expected.hunks == 0);
+	cl_assert(expected.lines == 0);
+}
+
+void test_diff_blob__can_compare_identical_blobs(void)
+{
+	cl_git_pass(git_diff_blobs(
+		d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+	assert_identical_blobs_comparison(expected);
+
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_blobs(
+		NULL, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.at_least_one_of_them_is_binary == false);
+	assert_identical_blobs_comparison(expected);
+
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_blobs(
+		alien, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(expected.at_least_one_of_them_is_binary == true);
+	assert_identical_blobs_comparison(expected);
+}
+
+static void assert_binary_blobs_comparison(diff_expects expected)
+{
+	cl_assert(expected.at_least_one_of_them_is_binary == true);
+
+	cl_assert(expected.files == 1);
+	cl_assert(expected.file_mods == 1);
+	cl_assert(expected.hunks == 0);
+	cl_assert(expected.lines == 0);
+}
+
+void test_diff_blob__can_compare_two_binary_blobs(void)
+{
+	git_blob *heart;
+	git_oid h_oid;
+
+	/* heart.png */
+	cl_git_pass(git_oid_fromstrn(&h_oid, "de863bff", 8));
+	cl_git_pass(git_blob_lookup_prefix(&heart, g_repo, &h_oid, 4));
+
+	cl_git_pass(git_diff_blobs(
+		alien, heart, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	assert_binary_blobs_comparison(expected);
+
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_blobs(
+		heart, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	assert_binary_blobs_comparison(expected);
+
+	git_blob_free(heart);
+}
+
+void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
+{
+	cl_git_pass(git_diff_blobs(
+		alien, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	assert_binary_blobs_comparison(expected);
+
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_blobs(
+		d, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	assert_binary_blobs_comparison(expected);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/diff/diff_helpers.c

@@ -0,0 +1,104 @@
+#include "clar_libgit2.h"
+#include "diff_helpers.h"
+
+git_tree *resolve_commit_oid_to_tree(
+	git_repository *repo,
+	const char *partial_oid)
+{
+	unsigned int len = (unsigned int)strlen(partial_oid);
+	git_oid oid;
+	git_object *obj = NULL;
+	git_tree *tree = NULL;
+
+	if (git_oid_fromstrn(&oid, partial_oid, len) == 0)
+		git_object_lookup_prefix(&obj, repo, &oid, len, GIT_OBJ_ANY);
+	cl_assert(obj);
+	if (git_object_type(obj) == GIT_OBJ_TREE)
+		return (git_tree *)obj;
+	cl_assert(git_object_type(obj) == GIT_OBJ_COMMIT);
+	cl_git_pass(git_commit_tree(&tree, (git_commit *)obj));
+	git_object_free(obj);
+	return tree;
+}
+
+int diff_file_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	float progress)
+{
+	diff_expects *e = cb_data;
+
+	GIT_UNUSED(progress);
+
+	e->	at_least_one_of_them_is_binary = delta->binary;
+
+	e->files++;
+	switch (delta->status) {
+	case GIT_DELTA_ADDED: e->file_adds++; break;
+	case GIT_DELTA_DELETED: e->file_dels++; break;
+	case GIT_DELTA_MODIFIED: e->file_mods++; break;
+	case GIT_DELTA_IGNORED: e->file_ignored++; break;
+	case GIT_DELTA_UNTRACKED: e->file_untracked++; break;
+	case GIT_DELTA_UNMODIFIED: e->file_unmodified++; break;
+	default: break;
+	}
+	return 0;
+}
+
+int diff_hunk_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	git_diff_range *range,
+	const char *header,
+	size_t header_len)
+{
+	diff_expects *e = cb_data;
+
+	GIT_UNUSED(delta);
+	GIT_UNUSED(header);
+	GIT_UNUSED(header_len);
+
+	e->hunks++;
+	e->hunk_old_lines += range->old_lines;
+	e->hunk_new_lines += range->new_lines;
+	return 0;
+}
+
+int diff_line_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	git_diff_range *range,
+	char line_origin,
+	const char *content,
+	size_t content_len)
+{
+	diff_expects *e = cb_data;
+
+	GIT_UNUSED(delta);
+	GIT_UNUSED(range);
+	GIT_UNUSED(content);
+	GIT_UNUSED(content_len);
+
+	e->lines++;
+	switch (line_origin) {
+	case GIT_DIFF_LINE_CONTEXT:
+		e->line_ctxt++;
+		break;
+	case GIT_DIFF_LINE_ADDITION:
+		e->line_adds++;
+		break;
+	case GIT_DIFF_LINE_ADD_EOFNL:
+		assert(0);
+		break;
+	case GIT_DIFF_LINE_DELETION:
+		e->line_dels++;
+		break;
+	case GIT_DIFF_LINE_DEL_EOFNL:
+		/* technically not a line delete, but we'll count it as such */
+		e->line_dels++;
+		break;
+	default:
+		break;
+	}
+	return 0;
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/diff/diff_helpers.h

@@ -0,0 +1,47 @@
+#include "fileops.h"
+#include "git2/diff.h"
+
+extern git_tree *resolve_commit_oid_to_tree(
+	git_repository *repo, const char *partial_oid);
+
+typedef struct {
+	int files;
+	int file_adds;
+	int file_dels;
+	int file_mods;
+	int file_ignored;
+	int file_untracked;
+	int file_unmodified;
+
+	int hunks;
+	int hunk_new_lines;
+	int hunk_old_lines;
+
+	int lines;
+	int line_ctxt;
+	int line_adds;
+	int line_dels;
+
+	bool at_least_one_of_them_is_binary;
+} diff_expects;
+
+extern int diff_file_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	float progress);
+
+extern int diff_hunk_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	git_diff_range *range,
+	const char *header,
+	size_t header_len);
+
+extern int diff_line_fn(
+	void *cb_data,
+	git_diff_delta *delta,
+	git_diff_range *range,
+	char line_origin,
+	const char *content,
+	size_t content_len);
+

data/ext/rugged/vendor/libgit2-dist/tests-clar/diff/index.c

@@ -0,0 +1,92 @@
+#include "clar_libgit2.h"
+#include "diff_helpers.h"
+
+static git_repository *g_repo = NULL;
+
+void test_diff_index__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("status");
+}
+
+void test_diff_index__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_diff_index__0(void)
+{
+	/* grabbed a couple of commit oids from the history of the attr repo */
+	const char *a_commit = "26a125ee1bf"; /* the current HEAD */
+	const char *b_commit = "0017bd4ab1ec3"; /* the start */
+	git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit);
+	git_tree *b = resolve_commit_oid_to_tree(g_repo, b_commit);
+	git_diff_options opts = {0};
+	git_diff_list *diff = NULL;
+	diff_expects exp;
+
+	cl_assert(a);
+	cl_assert(b);
+
+	opts.context_lines = 1;
+	opts.interhunk_lines = 1;
+
+	memset(&exp, 0, sizeof(exp));
+
+	cl_git_pass(git_diff_index_to_tree(g_repo, &opts, a, &diff));
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	/* to generate these values:
+	 * - cd to tests/resources/status,
+	 * - mv .gitted .git
+	 * - git diff --name-status --cached 26a125ee1bf
+	 * - git diff -U1 --cached 26a125ee1bf
+	 * - mv .git .gitted
+	 */
+	cl_assert(exp.files == 8);
+	cl_assert(exp.file_adds == 3);
+	cl_assert(exp.file_dels == 2);
+	cl_assert(exp.file_mods == 3);
+
+	cl_assert(exp.hunks == 8);
+
+	cl_assert(exp.lines == 11);
+	cl_assert(exp.line_ctxt == 3);
+	cl_assert(exp.line_adds == 6);
+	cl_assert(exp.line_dels == 2);
+
+	git_diff_list_free(diff);
+	diff = NULL;
+	memset(&exp, 0, sizeof(exp));
+
+	cl_git_pass(git_diff_index_to_tree(g_repo, &opts, b, &diff));
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	/* to generate these values:
+	 * - cd to tests/resources/status,
+	 * - mv .gitted .git
+	 * - git diff --name-status --cached 0017bd4ab1ec3
+	 * - git diff -U1 --cached 0017bd4ab1ec3
+	 * - mv .git .gitted
+	 */
+	cl_assert(exp.files == 12);
+	cl_assert(exp.file_adds == 7);
+	cl_assert(exp.file_dels == 2);
+	cl_assert(exp.file_mods == 3);
+
+	cl_assert(exp.hunks == 12);
+
+	cl_assert(exp.lines == 16);
+	cl_assert(exp.line_ctxt == 3);
+	cl_assert(exp.line_adds == 11);
+	cl_assert(exp.line_dels == 2);
+
+	git_diff_list_free(diff);
+	diff = NULL;
+
+	git_tree_free(a);
+	git_tree_free(b);
+}