rugged 0.16.0 → 0.17.0b1

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

@@ -0,0 +1,123 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+
+static const char *new_ref = "refs/heads/test-reflog";
+static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+static const char *commit_msg = "commit: bla bla";
+
+static git_repository *g_repo;
+
+
+// helpers
+static void assert_signature(git_signature *expected, git_signature *actual)
+{
+	cl_assert(actual);
+	cl_assert_equal_s(expected->name, actual->name);
+	cl_assert_equal_s(expected->email, actual->email);
+	cl_assert(expected->when.offset == actual->when.offset);
+	cl_assert(expected->when.time == actual->when.time);
+}
+
+
+// Fixture setup and teardown
+void test_refs_reflog__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_reflog__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+
+void test_refs_reflog__write_then_read(void)
+{
+   // write a reflog for a given reference and ensure it can be read back
+   git_repository *repo2;
+	git_reference *ref, *lookedup_ref;
+	git_oid oid;
+	git_signature *committer;
+	git_reflog *reflog;
+	git_reflog_entry *entry;
+	char oid_str[GIT_OID_HEXSZ+1];
+
+	/* Create a new branch pointing at the HEAD */
+	git_oid_fromstr(&oid, current_master_tip);
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, new_ref, &oid, 0));
+	git_reference_free(ref);
+	cl_git_pass(git_reference_lookup(&ref, g_repo, new_ref));
+
+	cl_git_pass(git_signature_now(&committer, "foo", "foo@bar"));
+
+	cl_git_pass(git_reflog_write(ref, NULL, committer, NULL));
+	cl_git_fail(git_reflog_write(ref, NULL, committer, "no ancestor NULL for an existing reflog"));
+	cl_git_fail(git_reflog_write(ref, NULL, committer, "no\nnewline"));
+	cl_git_pass(git_reflog_write(ref, &oid, committer, commit_msg));
+
+	/* Reopen a new instance of the repository */
+	cl_git_pass(git_repository_open(&repo2, "testrepo"));
+
+	/* Lookup the preivously created branch */
+	cl_git_pass(git_reference_lookup(&lookedup_ref, repo2, new_ref));
+
+	/* Read and parse the reflog for this branch */
+	cl_git_pass(git_reflog_read(&reflog, lookedup_ref));
+	cl_assert(reflog->entries.length == 2);
+
+	entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 0);
+	assert_signature(committer, entry->committer);
+	git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old);
+	cl_assert_equal_s("0000000000000000000000000000000000000000", oid_str);
+	git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur);
+	cl_assert_equal_s(current_master_tip, oid_str);
+	cl_assert(entry->msg == NULL);
+
+	entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 1);
+	assert_signature(committer, entry->committer);
+	git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old);
+	cl_assert_equal_s(current_master_tip, oid_str);
+	git_oid_tostr(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur);
+	cl_assert_equal_s(current_master_tip, oid_str);
+	cl_assert_equal_s(commit_msg, entry->msg);
+
+	git_signature_free(committer);
+	git_reflog_free(reflog);
+	git_repository_free(repo2);
+
+	git_reference_free(ref);
+	git_reference_free(lookedup_ref);
+}
+
+void test_refs_reflog__dont_write_bad(void)
+{
+   // avoid writing an obviously wrong reflog
+	git_reference *ref;
+	git_oid oid;
+	git_signature *committer;
+
+	/* Create a new branch pointing at the HEAD */
+	git_oid_fromstr(&oid, current_master_tip);
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, new_ref, &oid, 0));
+	git_reference_free(ref);
+	cl_git_pass(git_reference_lookup(&ref, g_repo, new_ref));
+
+	cl_git_pass(git_signature_now(&committer, "foo", "foo@bar"));
+
+	/* Write the reflog for the new branch */
+	cl_git_pass(git_reflog_write(ref, NULL, committer, NULL));
+
+	/* Try to update the reflog with wrong information:
+	 * It's no new reference, so the ancestor OID cannot
+	 * be NULL. */
+	cl_git_fail(git_reflog_write(ref, NULL, committer, NULL));
+
+	git_signature_free(committer);
+
+	git_reference_free(ref);
+}

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

@@ -0,0 +1,339 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+static const char *loose_tag_ref_name = "refs/tags/e90810b";
+static const char *packed_head_name = "refs/heads/packed";
+static const char *packed_test_head_name = "refs/heads/packed-test";
+static const char *ref_one_name = "refs/heads/one/branch";
+static const char *ref_one_name_new = "refs/heads/two/branch";
+static const char *ref_two_name = "refs/heads/two";
+static const char *ref_master_name = "refs/heads/master";
+static const char *ref_two_name_new = "refs/heads/two/two";
+
+static git_repository *g_repo;
+
+
+
+void test_refs_rename__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_rename__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+
+void test_refs_rename__loose(void)
+{
+   // rename a loose reference
+	git_reference *looked_up_ref, *another_looked_up_ref;
+	git_buf temp_path = GIT_BUF_INIT;
+	const char *new_name = "refs/tags/Nemo/knows/refs.kung-fu";
+
+	/* Ensure the ref doesn't exist on the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, new_name));
+	cl_assert(!git_path_exists(temp_path.ptr));
+
+	/* Retrieval of the reference to rename */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, loose_tag_ref_name));
+
+	/* ... which is indeed loose */
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+
+	/* Now that the reference is renamed... */
+	cl_git_pass(git_reference_rename(looked_up_ref, new_name, 0));
+	cl_assert_equal_s(looked_up_ref->name, new_name);
+
+	/* ...It can't be looked-up with the old name... */
+	cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, loose_tag_ref_name));
+
+	/* ...but the new name works ok... */
+	cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, new_name));
+	cl_assert_equal_s(another_looked_up_ref->name, new_name);
+
+	/* .. the ref is still loose... */
+	cl_assert(git_reference_is_packed(another_looked_up_ref) == 0);
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+
+	/* ...and the ref can be found in the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, new_name));
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	git_reference_free(looked_up_ref);
+	git_reference_free(another_looked_up_ref);
+	git_buf_free(&temp_path);
+}
+
+void test_refs_rename__packed(void)
+{
+   // rename a packed reference (should make it loose)
+	git_reference *looked_up_ref, *another_looked_up_ref;
+	git_buf temp_path = GIT_BUF_INIT;
+	const char *brand_new_name = "refs/heads/brand_new_name";
+
+	/* Ensure the ref doesn't exist on the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_head_name));
+	cl_assert(!git_path_exists(temp_path.ptr));
+
+	/* The reference can however be looked-up... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+
+	/* .. and it's packed */
+	cl_assert(git_reference_is_packed(looked_up_ref) != 0);
+
+	/* Now that the reference is renamed... */
+	cl_git_pass(git_reference_rename(looked_up_ref, brand_new_name, 0));
+	cl_assert_equal_s(looked_up_ref->name, brand_new_name);
+
+	/* ...It can't be looked-up with the old name... */
+	cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, packed_head_name));
+
+	/* ...but the new name works ok... */
+	cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, brand_new_name));
+	cl_assert_equal_s(another_looked_up_ref->name, brand_new_name);
+
+	/* .. the ref is no longer packed... */
+	cl_assert(git_reference_is_packed(another_looked_up_ref) == 0);
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+
+	/* ...and the ref now happily lives in the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, brand_new_name));
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	git_reference_free(looked_up_ref);
+	git_reference_free(another_looked_up_ref);
+	git_buf_free(&temp_path);
+}
+
+void test_refs_rename__packed_doesnt_pack_others(void)
+{
+   // renaming a packed reference does not pack another reference which happens to be in both loose and pack state
+	git_reference *looked_up_ref, *another_looked_up_ref;
+	git_buf temp_path = GIT_BUF_INIT;
+	const char *brand_new_name = "refs/heads/brand_new_name";
+
+	/* Ensure the other reference exists on the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_test_head_name));
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	/* Lookup the other reference */
+	cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, packed_test_head_name));
+
+	/* Ensure it's loose */
+	cl_assert(git_reference_is_packed(another_looked_up_ref) == 0);
+	git_reference_free(another_looked_up_ref);
+
+	/* Lookup the reference to rename */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+
+	/* Ensure it's packed */
+	cl_assert(git_reference_is_packed(looked_up_ref) != 0);
+
+	/* Now that the reference is renamed... */
+	cl_git_pass(git_reference_rename(looked_up_ref, brand_new_name, 0));
+
+	/* Lookup the other reference */
+	cl_git_pass(git_reference_lookup(&another_looked_up_ref, g_repo, packed_test_head_name));
+
+	/* Ensure it's loose */
+	cl_assert(git_reference_is_packed(another_looked_up_ref) == 0);
+
+	/* Ensure the other ref still exists on the file system */
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	git_reference_free(looked_up_ref);
+	git_reference_free(another_looked_up_ref);
+	git_buf_free(&temp_path);
+}
+
+void test_refs_rename__name_collision(void)
+{
+   // can not rename a reference with the name of an existing reference
+	git_reference *looked_up_ref;
+
+	/* An existing reference... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+
+	/* Can not be renamed to the name of another existing reference. */
+	cl_git_fail(git_reference_rename(looked_up_ref, packed_test_head_name, 0));
+	git_reference_free(looked_up_ref);
+
+	/* Failure to rename it hasn't corrupted its state */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+	cl_assert_equal_s(looked_up_ref->name, packed_head_name);
+
+	git_reference_free(looked_up_ref);
+}
+
+void test_refs_rename__invalid_name(void)
+{
+   // can not rename a reference with an invalid name
+	git_reference *looked_up_ref;
+
+	/* An existing oid reference... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name));
+
+	/* Can not be renamed with an invalid name. */
+	cl_git_fail(git_reference_rename(looked_up_ref, "Hello! I'm a very invalid name.", 0));
+
+	/* Can not be renamed outside of the refs hierarchy. */
+	cl_git_fail(git_reference_rename(looked_up_ref, "i-will-sudo-you", 0));
+
+	/* Failure to rename it hasn't corrupted its state */
+	git_reference_free(looked_up_ref);
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name));
+	cl_assert_equal_s(looked_up_ref->name, packed_test_head_name);
+
+	git_reference_free(looked_up_ref);
+}
+
+void test_refs_rename__force_loose_packed(void)
+{
+   // can force-rename a packed reference with the name of an existing loose and packed reference
+	git_reference *looked_up_ref;
+	git_oid oid;
+
+	/* An existing reference... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+	git_oid_cpy(&oid, git_reference_oid(looked_up_ref));
+
+	/* Can be force-renamed to the name of another existing reference. */
+	cl_git_pass(git_reference_rename(looked_up_ref, packed_test_head_name, 1));
+	git_reference_free(looked_up_ref);
+
+	/* Check we actually renamed it */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name));
+	cl_assert_equal_s(looked_up_ref->name, packed_test_head_name);
+	cl_assert(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref)));
+	git_reference_free(looked_up_ref);
+
+	/* And that the previous one doesn't exist any longer */
+	cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
+}
+
+void test_refs_rename__force_loose(void)
+{
+   // can force-rename a loose reference with the name of an existing loose reference
+	git_reference *looked_up_ref;
+	git_oid oid;
+
+	/* An existing reference... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/br2"));
+	git_oid_cpy(&oid, git_reference_oid(looked_up_ref));
+
+	/* Can be force-renamed to the name of another existing reference. */
+   cl_git_pass(git_reference_rename(looked_up_ref, "refs/heads/test", 1));
+	git_reference_free(looked_up_ref);
+
+	/* Check we actually renamed it */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/test"));
+	cl_assert_equal_s(looked_up_ref->name,  "refs/heads/test");
+	cl_assert(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref)));
+	git_reference_free(looked_up_ref);
+
+	/* And that the previous one doesn't exist any longer */
+	cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, "refs/heads/br2"));
+
+	git_reference_free(looked_up_ref);
+}
+
+
+void test_refs_rename__overwrite(void)
+{
+   // can not overwrite name of existing reference
+	git_reference *ref, *ref_one, *ref_one_new, *ref_two;
+	git_oid id;
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_OID);
+
+	git_oid_cpy(&id, git_reference_oid(ref));
+
+	/* Create loose references */
+	cl_git_pass(git_reference_create_oid(&ref_one, g_repo, ref_one_name, &id, 0));
+	cl_git_pass(git_reference_create_oid(&ref_two, g_repo, ref_two_name, &id, 0));
+
+	/* Pack everything */
+	cl_git_pass(git_reference_packall(g_repo));
+
+	/* Attempt to create illegal reference */
+	cl_git_fail(git_reference_create_oid(&ref_one_new, g_repo, ref_one_name_new, &id, 0));
+
+	/* Illegal reference couldn't be created so this is supposed to fail */
+	cl_git_fail(git_reference_lookup(&ref_one_new, g_repo, ref_one_name_new));
+
+	git_reference_free(ref);
+	git_reference_free(ref_one);
+	git_reference_free(ref_one_new);
+	git_reference_free(ref_two);
+}
+
+
+void test_refs_rename__prefix(void)
+{
+   // can be renamed to a new name prefixed with the old name
+	git_reference *ref, *ref_two, *looked_up_ref;
+	git_oid id;
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_OID);
+
+	git_oid_cpy(&id, git_reference_oid(ref));
+
+	/* Create loose references */
+	cl_git_pass(git_reference_create_oid(&ref_two, g_repo, ref_two_name, &id, 0));
+
+	/* An existing reference... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name));
+
+	/* Can be rename to a new name starting with the old name. */
+	cl_git_pass(git_reference_rename(looked_up_ref, ref_two_name_new, 0));
+	git_reference_free(looked_up_ref);
+
+	/* Check we actually renamed it */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new));
+	cl_assert_equal_s(looked_up_ref->name, ref_two_name_new);
+	git_reference_free(looked_up_ref);
+	cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name));
+
+	git_reference_free(ref);
+	git_reference_free(ref_two);
+	git_reference_free(looked_up_ref);
+}
+
+void test_refs_rename__move_up(void)
+{
+   // can move a reference to a upper reference hierarchy
+    git_reference *ref, *ref_two, *looked_up_ref;
+    git_oid id;
+
+    cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name));
+    cl_assert(git_reference_type(ref) & GIT_REF_OID);
+
+    git_oid_cpy(&id, git_reference_oid(ref));
+
+    /* Create loose references */
+    cl_git_pass(git_reference_create_oid(&ref_two, g_repo, ref_two_name_new, &id, 0));
+    git_reference_free(ref_two);
+
+    /* An existing reference... */
+    cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new));
+
+    /* Can be renamed upward the reference tree. */
+    cl_git_pass(git_reference_rename(looked_up_ref, ref_two_name, 0));
+    git_reference_free(looked_up_ref);
+
+    /* Check we actually renamed it */
+    cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name));
+    cl_assert_equal_s(looked_up_ref->name, ref_two_name);
+    git_reference_free(looked_up_ref);
+    cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new));
+    git_reference_free(ref);
+    git_reference_free(looked_up_ref);
+}

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

@@ -0,0 +1,174 @@
+#include "clar_libgit2.h"
+
+#include "git2/revparse.h"
+
+static git_repository *g_repo;
+static git_object *g_obj;
+static char g_orig_tz[16] = {0};
+
+
+
+/* Helpers */
+static void test_object(const char *spec, const char *expected_oid)
+{
+   char objstr[64] = {0};
+
+   cl_git_pass(git_revparse_single(&g_obj, g_repo, spec));
+   git_oid_fmt(objstr, git_object_id(g_obj));
+   cl_assert_equal_s(objstr, expected_oid);
+
+   git_object_free(g_obj);
+   g_obj = NULL;
+}
+
+
+void test_refs_revparse__initialize(void)
+{
+   char *tz = cl_getenv("TZ");
+   if (tz)
+      strcpy(g_orig_tz, tz);
+   cl_setenv("TZ", "UTC");
+   g_repo = cl_git_sandbox_init("testrepo.git");
+}
+
+void test_refs_revparse__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+   g_obj = NULL;
+   cl_setenv("TZ", g_orig_tz);
+}
+
+
+void test_refs_revparse__nonexistant_object(void)
+{
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist^1"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "this doesn't exist~2"));
+}
+
+void test_refs_revparse__shas(void)
+{
+   test_object("c47800c7266a2be04c571c04d5a6614691ea99bd", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+   test_object("c47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+}
+
+void test_refs_revparse__head(void)
+{
+   test_object("HEAD", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+}
+
+void test_refs_revparse__full_refs(void)
+{
+   test_object("refs/heads/master", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("refs/heads/test", "e90810b8df3e80c413d903f631643c716887138d");
+   test_object("refs/tags/test", "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
+}
+
+void test_refs_revparse__partial_refs(void)
+{
+   test_object("point_to_blob", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+   test_object("packed-test", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
+   test_object("br2", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+}
+
+void test_refs_revparse__describe_output(void)
+{
+   test_object("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+   test_object("not-good", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+}
+
+void test_refs_revparse__nth_parent(void)
+{
+   test_object("be3563a^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+   test_object("be3563a^", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+   test_object("be3563a^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+   test_object("be3563a^1^1", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045");
+   test_object("be3563a^2^1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+   test_object("be3563a^0", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+}
+
+void test_refs_revparse__not_tag(void)
+{
+   test_object("point_to_blob^{}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+   test_object("wrapped_tag^{}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+}
+
+void test_refs_revparse__to_type(void)
+{
+   test_object("wrapped_tag^{commit}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("wrapped_tag^{tree}", "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162");
+   test_object("point_to_blob^{blob}", "1385f264afb75a56a5bec74243be9b367ba4ca08");
+
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "wrapped_tag^{blob}"));
+}
+
+void test_refs_revparse__linear_history(void)
+{
+   test_object("master~0", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("master~1", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("master~2", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+   test_object("master~1~1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+}
+
+void test_refs_revparse__chaining(void)
+{
+   test_object("master~1^1", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+   test_object("master~1^2", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+   test_object("master^1^2~1", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+   test_object("master^1^1^1^1^1", "8496071c1b46c854b31185ea97743be6a8774479");
+}
+
+void test_refs_revparse__reflog(void)
+{
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-xyz}"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{-0}"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "@{1000}"));
+
+   test_object("@{-2}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("@{-1}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+   test_object("master@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("master@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("@{1}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("master@{upstream}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("master@{u}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+}
+
+void test_refs_revparse__revwalk(void)
+{
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/not found in any commit}"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/merge}"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, "master^{/((}"));
+
+   test_object("master^{/anoth}", "5b5b025afb0b4c913b4c338a42934a3863bf3644");
+   test_object("master^{/Merge}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("br2^{/Merge}", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+   test_object("master^{/fo.rth}", "9fd738e8f7967c078dceed8190330fc8648ee56a");
+}
+
+void test_refs_revparse__date(void)
+{
+   test_object("HEAD@{10 years ago}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("HEAD@{1 second}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("master@{2012-4-30 10:23:20 -0800}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+   test_object("master@{2012-4-30 18:24 -0800}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+   test_object("master@{2012-4-30 23:24 -0300}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+
+   /* Core git gives a65fedf, because they don't take time zones into account. */
+   test_object("master@{1335806640}", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+}
+
+void test_refs_revparse__colon(void)
+{
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":/not found in any commit"));
+   cl_git_fail(git_revparse_single(&g_obj, g_repo, ":2:README"));
+
+   test_object("subtrees:ab/4.txt", "d6c93164c249c8000205dd4ec5cbca1b516d487f");
+   test_object("subtrees:ab/de/fgh/1.txt", "1f67fc4386b2d171e0d21be1c447e12660561f9b");
+   test_object("master:README", "a8233120f6ad708f843d861ce2b7228ec4e3dec6");
+   test_object("master:new.txt", "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd");
+   test_object(":/Merge", "a4a7dce85cf63874e984719f4fdd239f5145052f");
+   test_object(":/one", "c47800c7266a2be04c571c04d5a6614691ea99bd");
+   test_object(":/packed commit t", "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9");
+}

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

@@ -0,0 +1,42 @@
+#include "clar_libgit2.h"
+
+static git_repository *repo;
+
+void test_refs_unicode__initialize(void)
+{
+	cl_fixture_sandbox("testrepo.git");
+
+	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+}
+
+void test_refs_unicode__cleanup(void)
+{
+	git_repository_free(repo);
+	cl_fixture_cleanup("testrepo.git");
+}
+
+void test_refs_unicode__create_and_lookup(void)
+{
+	git_reference *ref0, *ref1, *ref2;
+	git_repository *repo2;
+
+	const char *REFNAME = "refs/heads/" "\305" "ngstr" "\366" "m";
+	const char *master = "refs/heads/master";
+
+	/* Create the reference */
+	cl_git_pass(git_reference_lookup(&ref0, repo, master));
+	cl_git_pass(git_reference_create_oid(&ref1, repo, REFNAME, git_reference_oid(ref0), 0));
+	cl_assert(strcmp(REFNAME, git_reference_name(ref1)) == 0);
+
+	/* Lookup the reference in a different instance of the repository */
+	cl_git_pass(git_repository_open(&repo2, "testrepo.git"));
+	cl_git_pass(git_reference_lookup(&ref2, repo2, REFNAME));
+
+	cl_assert(git_oid_cmp(git_reference_oid(ref1), git_reference_oid(ref2)) == 0);
+	cl_assert(strcmp(REFNAME, git_reference_name(ref2)) == 0);
+
+	git_reference_free(ref0);
+	git_reference_free(ref1);
+	git_reference_free(ref2);
+	git_repository_free(repo2);
+}