rugged 0.17.0b2 → 0.17.0.b6

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

@@ -1,194 +0,0 @@
-#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 *non_existing_tag_ref_name = "refs/tags/i-do-not-exist";
-static const char *head_tracker_sym_ref_name = "head-tracker";
-static const char *current_head_target = "refs/heads/master";
-static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
-static const char *packed_head_name = "refs/heads/packed";
-static const char *packed_test_head_name = "refs/heads/packed-test";
-
-static git_repository *g_repo;
-
-void test_refs_read__initialize(void)
-{
-   g_repo = cl_git_sandbox_init("testrepo");
-}
-
-void test_refs_read__cleanup(void)
-{
-   cl_git_sandbox_cleanup();
-}
-
-void test_refs_read__loose_tag(void)
-{
-   // lookup a loose tag reference
-	git_reference *reference;
-	git_object *object;
-	git_buf ref_name_from_tag_name = GIT_BUF_INIT;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name));
-	cl_assert(git_reference_type(reference) & GIT_REF_OID);
-	cl_assert(git_reference_is_packed(reference) == 0);
-	cl_assert_equal_s(reference->name, loose_tag_ref_name);
-
-	cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(reference), GIT_OBJ_ANY));
-	cl_assert(object != NULL);
-	cl_assert(git_object_type(object) == GIT_OBJ_TAG);
-
-	/* Ensure the name of the tag matches the name of the reference */
-	cl_git_pass(git_buf_joinpath(&ref_name_from_tag_name, GIT_REFS_TAGS_DIR, git_tag_name((git_tag *)object)));
-	cl_assert_equal_s(ref_name_from_tag_name.ptr, loose_tag_ref_name);
-	git_buf_free(&ref_name_from_tag_name);
-
-	git_object_free(object);
-
-	git_reference_free(reference);
-}
-
-void test_refs_read__nonexisting_tag(void)
-{
-   // lookup a loose tag reference that doesn't exist
-	git_reference *reference;
-
-	cl_git_fail(git_reference_lookup(&reference, g_repo, non_existing_tag_ref_name));
-
-	git_reference_free(reference);
-}
-
-
-void test_refs_read__symbolic(void)
-{
-   // lookup a symbolic reference
-	git_reference *reference, *resolved_ref;
-	git_object *object;
-	git_oid id;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
-	cl_assert(git_reference_type(reference) & GIT_REF_SYMBOLIC);
-	cl_assert(git_reference_is_packed(reference) == 0);
-	cl_assert_equal_s(reference->name, GIT_HEAD_FILE);
-
-	cl_git_pass(git_reference_resolve(&resolved_ref, reference));
-	cl_assert(git_reference_type(resolved_ref) == GIT_REF_OID);
-
-	cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
-	cl_assert(object != NULL);
-	cl_assert(git_object_type(object) == GIT_OBJ_COMMIT);
-
-	git_oid_fromstr(&id, current_master_tip);
-	cl_assert(git_oid_cmp(&id, git_object_id(object)) == 0);
-
-	git_object_free(object);
-
-	git_reference_free(reference);
-	git_reference_free(resolved_ref);
-}
-
-void test_refs_read__nested_symbolic(void)
-{
-   // lookup a nested symbolic reference
-	git_reference *reference, *resolved_ref;
-	git_object *object;
-	git_oid id;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, head_tracker_sym_ref_name));
-	cl_assert(git_reference_type(reference) & GIT_REF_SYMBOLIC);
-	cl_assert(git_reference_is_packed(reference) == 0);
-	cl_assert_equal_s(reference->name, head_tracker_sym_ref_name);
-
-	cl_git_pass(git_reference_resolve(&resolved_ref, reference));
-	cl_assert(git_reference_type(resolved_ref) == GIT_REF_OID);
-
-	cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
-	cl_assert(object != NULL);
-	cl_assert(git_object_type(object) == GIT_OBJ_COMMIT);
-
-	git_oid_fromstr(&id, current_master_tip);
-	cl_assert(git_oid_cmp(&id, git_object_id(object)) == 0);
-
-	git_object_free(object);
-
-	git_reference_free(reference);
-	git_reference_free(resolved_ref);
-}
-
-void test_refs_read__head_then_master(void)
-{
-   // lookup the HEAD and resolve the master branch
-	git_reference *reference, *resolved_ref, *comp_base_ref;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, head_tracker_sym_ref_name));
-	cl_git_pass(git_reference_resolve(&comp_base_ref, reference));
-	git_reference_free(reference);
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
-	cl_git_pass(git_reference_resolve(&resolved_ref, reference));
-	cl_git_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
-	git_reference_free(reference);
-	git_reference_free(resolved_ref);
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, current_head_target));
-	cl_git_pass(git_reference_resolve(&resolved_ref, reference));
-	cl_git_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
-	git_reference_free(reference);
-	git_reference_free(resolved_ref);
-
-	git_reference_free(comp_base_ref);
-}
-
-void test_refs_read__master_then_head(void)
-{
-   // lookup the master branch and then the HEAD
-	git_reference *reference, *master_ref, *resolved_ref;
-
-	cl_git_pass(git_reference_lookup(&master_ref, g_repo, current_head_target));
-	cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
-
-	cl_git_pass(git_reference_resolve(&resolved_ref, reference));
-	cl_git_pass(git_oid_cmp(git_reference_oid(master_ref), git_reference_oid(resolved_ref)));
-
-	git_reference_free(reference);
-	git_reference_free(resolved_ref);
-	git_reference_free(master_ref);
-}
-
-
-void test_refs_read__packed(void)
-{
-   // lookup a packed reference
-	git_reference *reference;
-	git_object *object;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, packed_head_name));
-	cl_assert(git_reference_type(reference) & GIT_REF_OID);
-	cl_assert(git_reference_is_packed(reference));
-	cl_assert_equal_s(reference->name, packed_head_name);
-
-	cl_git_pass(git_object_lookup(&object, g_repo, git_reference_oid(reference), GIT_OBJ_ANY));
-	cl_assert(object != NULL);
-	cl_assert(git_object_type(object) == GIT_OBJ_COMMIT);
-
-	git_object_free(object);
-
-	git_reference_free(reference);
-}
-
-void test_refs_read__loose_first(void)
-{
-   // assure that a loose reference is looked up before a packed reference
-	git_reference *reference;
-
-	cl_git_pass(git_reference_lookup(&reference, g_repo, packed_head_name));
-	git_reference_free(reference);
-	cl_git_pass(git_reference_lookup(&reference, g_repo, packed_test_head_name));
-	cl_assert(git_reference_type(reference) & GIT_REF_OID);
-	cl_assert(git_reference_is_packed(reference) == 0);
-	cl_assert_equal_s(reference->name, packed_test_head_name);
-
-	git_reference_free(reference);
-}

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

@@ -1,123 +0,0 @@
-#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

@@ -1,339 +0,0 @@
-#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);
-}