rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/tests/t05-revwalk.c

@@ -0,0 +1,140 @@
+/*
+ * 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 "test_lib.h"
+#include "test_helpers.h"
+
+/*
+	$ git log --oneline --graph --decorate
+	*   a4a7dce (HEAD, br2) Merge branch 'master' into br2
+	|\
+	| * 9fd738e (master) a fourth commit
+	| * 4a202b3 a third commit
+	* | c47800c branch commit one
+	|/
+	* 5b5b025 another commit
+	* 8496071 testing
+*/
+static const char *commit_head = "a4a7dce85cf63874e984719f4fdd239f5145052f";
+
+static const char *commit_ids[] = {
+	"a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
+	"9fd738e8f7967c078dceed8190330fc8648ee56a", /* 1 */
+	"4a202b346bb0fb0db7eff3cffeb3c70babbd2045", /* 2 */
+	"c47800c7266a2be04c571c04d5a6614691ea99bd", /* 3 */
+	"8496071c1b46c854b31185ea97743be6a8774479", /* 4 */
+	"5b5b025afb0b4c913b4c338a42934a3863bf3644", /* 5 */
+};
+
+/* Careful: there are two possible topological sorts */
+static const int commit_sorting_topo[][6] = {
+	{0, 1, 2, 3, 5, 4}, {0, 3, 1, 2, 5, 4}
+};
+
+static const int commit_sorting_time[][6] = {
+	{0, 3, 1, 2, 5, 4}
+};
+
+static const int commit_sorting_topo_reverse[][6] = {
+	{4, 5, 3, 2, 1, 0}, {4, 5, 2, 1, 3, 0}
+};
+
+static const int commit_sorting_time_reverse[][6] = {
+	{4, 5, 2, 1, 3, 0}
+};
+
+#define commit_count 6
+static const int result_bytes = 24;
+
+
+static int get_commit_index(git_oid *raw_oid)
+{
+	int i;
+	char oid[40];
+
+	git_oid_fmt(oid, raw_oid);
+
+	for (i = 0; i < commit_count; ++i)
+		if (memcmp(oid, commit_ids[i], 40) == 0)
+			return i;
+
+	return -1;
+}
+
+static int test_walk(git_revwalk *walk, const git_oid *root,
+		int flags, const int possible_results[][6], int results_count)
+{
+	git_oid oid;
+
+	int i;
+	int result_array[commit_count];
+
+	git_revwalk_sorting(walk, flags);
+	git_revwalk_push(walk, root);
+
+	for (i = 0; i < commit_count; ++i)
+		result_array[i] = -1;
+
+	i = 0;
+
+	while (git_revwalk_next(&oid, walk) == GIT_SUCCESS) {
+		result_array[i++] = get_commit_index(&oid);
+		/*{
+			char str[41];
+			git_oid_fmt(str, &oid);
+			str[40] = 0;
+			printf("  %d) %s\n", i, str);
+		}*/
+	}
+
+	for (i = 0; i < results_count; ++i)
+		if (memcmp(possible_results[i],
+				result_array, result_bytes) == 0)
+			return GIT_SUCCESS;
+
+	return GIT_ERROR;
+}
+
+BEGIN_TEST(walk0, "do a simple walk on a repo with different sorting modes")
+	git_oid id;
+	git_repository *repo;
+	git_revwalk *walk;
+
+	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
+	must_pass(git_revwalk_new(&walk, repo));
+
+	git_oid_fromstr(&id, commit_head);
+
+	must_pass(test_walk(walk, &id, GIT_SORT_TIME, commit_sorting_time, 1));
+	must_pass(test_walk(walk, &id, GIT_SORT_TOPOLOGICAL, commit_sorting_topo, 2));
+	must_pass(test_walk(walk, &id, GIT_SORT_TIME | GIT_SORT_REVERSE, commit_sorting_time_reverse, 1));
+	must_pass(test_walk(walk, &id, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE, commit_sorting_topo_reverse, 2));
+
+	git_revwalk_free(walk);
+	git_repository_free(repo);
+END_TEST
+
+BEGIN_SUITE(revwalk)
+	ADD_TEST(walk0);
+END_SUITE

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

@@ -0,0 +1,219 @@
+/*
+ * 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 "test_lib.h"
+#include "test_helpers.h"
+
+#include "index.h"
+
+#define TEST_INDEX_ENTRY_COUNT 109
+#define TEST_INDEX2_ENTRY_COUNT 1437
+
+struct test_entry {
+	unsigned int index;
+	char path[128];
+	git_off_t file_size;
+	git_time_t mtime;
+};
+
+struct test_entry TEST_ENTRIES[] = {
+	{4, "Makefile", 5064, 0x4C3F7F33},
+	{62, "tests/Makefile", 2631, 0x4C3F7F33},
+	{36, "src/index.c", 10014, 0x4C43368D},
+	{6, "git.git-authors", 2709, 0x4C3F7F33},
+	{48, "src/revobject.h", 1448, 0x4C3F7FE2}
+};
+
+BEGIN_TEST(read0, "load an empty index")
+	git_index *index;
+
+	must_pass(git_index_open(&index, "in-memory-index"));
+	must_be_true(index->on_disk == 0);
+
+	must_be_true(git_index_entrycount(index) == 0);
+	must_be_true(index->entries.sorted);
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(read1, "load a standard index (default test index)")
+	git_index *index;
+	unsigned int i;
+	git_index_entry **entries;
+
+	must_pass(git_index_open(&index, TEST_INDEX_PATH));
+	must_be_true(index->on_disk);
+
+	must_be_true(git_index_entrycount(index) == TEST_INDEX_ENTRY_COUNT);
+	must_be_true(index->entries.sorted);
+
+	entries = (git_index_entry **)index->entries.contents;
+
+	for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
+		git_index_entry *e = entries[TEST_ENTRIES[i].index];
+
+		must_be_true(strcmp(e->path, TEST_ENTRIES[i].path) == 0);
+		must_be_true(e->mtime.seconds == TEST_ENTRIES[i].mtime);
+		must_be_true(e->file_size == TEST_ENTRIES[i].file_size);
+	}
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(read2, "load a standard index (git.git index)")
+	git_index *index;
+
+	must_pass(git_index_open(&index, TEST_INDEX2_PATH));
+	must_be_true(index->on_disk);
+
+	must_be_true(git_index_entrycount(index) == TEST_INDEX2_ENTRY_COUNT);
+	must_be_true(index->entries.sorted);
+	must_be_true(index->tree != NULL);
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(find0, "find an entry on an index")
+	git_index *index;
+	unsigned int i;
+
+	must_pass(git_index_open(&index, TEST_INDEX_PATH));
+
+	for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
+		int idx = git_index_find(index, TEST_ENTRIES[i].path);
+		must_be_true((unsigned int)idx == TEST_ENTRIES[i].index);
+	}
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(find1, "find an entry in an empty index")
+	git_index *index;
+	unsigned int i;
+
+	must_pass(git_index_open(&index, "fake-index"));
+
+	for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
+		int idx = git_index_find(index, TEST_ENTRIES[i].path);
+		must_be_true(idx == GIT_ENOTFOUND);
+	}
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(write0, "write an index back to disk")
+	git_index *index;
+
+	must_pass(copy_file(TEST_INDEXBIG_PATH, "index_rewrite"));
+
+	must_pass(git_index_open(&index, "index_rewrite"));
+	must_be_true(index->on_disk);
+
+	must_pass(git_index_write(index));
+	must_pass(cmp_files(TEST_INDEXBIG_PATH, "index_rewrite"));
+
+	git_index_free(index);
+
+	p_unlink("index_rewrite");
+END_TEST
+
+BEGIN_TEST(sort0, "sort the entires in an index")
+	/*
+	 * TODO: This no longer applies:
+	 * index sorting in Git uses some specific changes to the way
+	 * directories are sorted.
+	 *
+	 * We need to specificially check for this by creating a new
+	 * index, adding entries in random order and then
+	 * checking for consistency
+	 */
+END_TEST
+
+BEGIN_TEST(sort1, "sort the entires in an empty index")
+	git_index *index;
+
+	must_pass(git_index_open(&index, "fake-index"));
+
+	/* FIXME: this test is slightly dumb */
+	must_be_true(index->entries.sorted);
+
+	git_index_free(index);
+END_TEST
+
+BEGIN_TEST(add0, "add a new file to the index")
+	git_index *index;
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_repository *repo;
+	git_index_entry *entry;
+	git_oid id1;
+
+	/* Intialize a new repository */
+	must_pass(git_repository_init(&repo, TEMP_REPO_FOLDER "myrepo", 0));
+
+	/* Ensure we're the only guy in the room */
+	must_pass(git_repository_index(&index, repo));
+	must_pass(git_index_entrycount(index) == 0);
+
+	/* Create a new file in the working directory */
+	must_pass(git_futils_mkpath2file(TEMP_REPO_FOLDER "myrepo/test.txt", 0777));
+	must_pass(git_filebuf_open(&file, TEMP_REPO_FOLDER "myrepo/test.txt", 0));
+	must_pass(git_filebuf_write(&file, "hey there\n", 10));
+	must_pass(git_filebuf_commit(&file, 0666));
+
+	/* Store the expected hash of the file/blob
+	 * This has been generated by executing the following
+	 * $ echo "hey there" | git hash-object --stdin
+	 */
+	must_pass(git_oid_fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6"));
+
+	/* Add the new file to the index */
+	must_pass(git_index_add(index, "test.txt", 0));
+
+	/* Wow... it worked! */
+	must_pass(git_index_entrycount(index) == 1);
+	entry = git_index_get(index, 0);
+
+	/* And the built-in hashing mechanism worked as expected */
+    must_be_true(git_oid_cmp(&id1, &entry->oid) == 0);
+
+    git_index_free(index);
+	git_repository_free(repo);
+	must_pass(git_futils_rmdir_r(TEMP_REPO_FOLDER, 1));
+END_TEST
+
+BEGIN_SUITE(index)
+	ADD_TEST(read0);
+	ADD_TEST(read1);
+	ADD_TEST(read2);
+
+	ADD_TEST(find0);
+	ADD_TEST(find1);
+
+	ADD_TEST(write0);
+
+	ADD_TEST(sort0);
+	ADD_TEST(sort1);
+
+	ADD_TEST(add0);
+END_SUITE

data/ext/rugged/vendor/libgit2-dist/tests/t07-hashtable.c

@@ -0,0 +1,192 @@
+/*
+ * 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 "test_lib.h"
+#include "test_helpers.h"
+
+#include "hashtable.h"
+#include "hash.h"
+
+typedef struct _aux_object {
+	int __bulk;
+	git_oid id;
+	int visited;
+} table_item;
+
+static uint32_t hash_func(const void *key, int hash_id)
+{
+	uint32_t r;
+	const git_oid *id = key;
+
+	memcpy(&r, id->id + (hash_id * sizeof(uint32_t)), sizeof(r));
+	return r;
+}
+
+static int hash_cmpkey(const void *a, const void *b)
+{
+	return git_oid_cmp(a, b);
+}
+
+BEGIN_TEST(table0, "create a new hashtable")
+
+	git_hashtable *table = NULL;
+
+	table = git_hashtable_alloc(55, hash_func, hash_cmpkey);
+	must_be_true(table != NULL);
+	must_be_true(table->size_mask + 1 == 64);
+
+	git_hashtable_free(table);
+
+END_TEST
+
+BEGIN_TEST(table1, "fill the hashtable with random entries")
+
+	const int objects_n = 32;
+	int i;
+
+	table_item *objects;
+	git_hashtable *table = NULL;
+
+	table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey);
+	must_be_true(table != NULL);
+
+	objects = git__malloc(objects_n * sizeof(table_item));
+	memset(objects, 0x0, objects_n * sizeof(table_item));
+
+	/* populate the hash table */
+	for (i = 0; i < objects_n; ++i) {
+		git_hash_buf(&(objects[i].id), &i, sizeof(int));
+		must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
+	}
+
+	/* make sure all the inserted objects can be found */
+	for (i = 0; i < objects_n; ++i) {
+		git_oid id;
+		table_item *ob;
+
+		git_hash_buf(&id, &i, sizeof(int));
+		ob = (table_item *)git_hashtable_lookup(table, &id);
+
+		must_be_true(ob != NULL);
+		must_be_true(ob == &(objects[i]));
+	}
+
+	/* make sure we cannot find inexisting objects */
+	for (i = 0; i < 50; ++i) {
+		int hash_id;
+		git_oid id;
+
+		hash_id = (rand() % 50000) + objects_n;
+		git_hash_buf(&id, &hash_id, sizeof(int));
+		must_be_true(git_hashtable_lookup(table, &id) == NULL);
+	}
+
+	git_hashtable_free(table);
+	git__free(objects);
+
+END_TEST
+
+
+BEGIN_TEST(table2, "make sure the table resizes automatically")
+
+	const int objects_n = 64;
+	int i;
+	unsigned int old_size;
+	table_item *objects;
+	git_hashtable *table = NULL;
+
+	table = git_hashtable_alloc(objects_n, hash_func, hash_cmpkey);
+	must_be_true(table != NULL);
+
+	objects = git__malloc(objects_n * sizeof(table_item));
+	memset(objects, 0x0, objects_n * sizeof(table_item));
+
+	old_size = table->size_mask + 1;
+
+	/* populate the hash table -- should be automatically resized */
+	for (i = 0; i < objects_n; ++i) {
+		git_hash_buf(&(objects[i].id), &i, sizeof(int));
+		must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
+	}
+
+	must_be_true(table->size_mask > old_size);
+
+	/* make sure all the inserted objects can be found */
+	for (i = 0; i < objects_n; ++i) {
+		git_oid id;
+		table_item *ob;
+
+		git_hash_buf(&id, &i, sizeof(int));
+		ob = (table_item *)git_hashtable_lookup(table, &id);
+
+		must_be_true(ob != NULL);
+		must_be_true(ob == &(objects[i]));
+	}
+
+	git_hashtable_free(table);
+	git__free(objects);
+
+END_TEST
+
+BEGIN_TEST(tableit0, "iterate through all the contents of the table")
+
+	const int objects_n = 32;
+	int i;
+	table_item *objects, *ob;
+	const void *GIT_UNUSED(_unused);
+
+	git_hashtable *table = NULL;
+
+	table = git_hashtable_alloc(objects_n * 2, hash_func, hash_cmpkey);
+	must_be_true(table != NULL);
+
+	objects = git__malloc(objects_n * sizeof(table_item));
+	memset(objects, 0x0, objects_n * sizeof(table_item));
+
+	/* populate the hash table */
+	for (i = 0; i < objects_n; ++i) {
+		git_hash_buf(&(objects[i].id), &i, sizeof(int));
+		must_pass(git_hashtable_insert(table, &(objects[i].id), &(objects[i])));
+	}
+
+	GIT_HASHTABLE_FOREACH(table, _unused, ob,
+		ob->visited = 1;
+	);
+
+	/* make sure all nodes have been visited */
+	for (i = 0; i < objects_n; ++i)
+		must_be_true(objects[i].visited);
+
+	git_hashtable_free(table);
+	git__free(objects);
+END_TEST
+
+
+BEGIN_SUITE(hashtable)
+	ADD_TEST(table0);
+	ADD_TEST(table1);
+	ADD_TEST(table2);
+	ADD_TEST(tableit0);
+END_SUITE
+