rugged 0.16.0 → 0.17.0b1

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

@@ -0,0 +1,200 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+
+// Helpers
+static void ensure_refname_normalized(int is_oid_ref,
+                                      const char *input_refname,
+                                      const char *expected_refname)
+{
+	char buffer_out[GIT_REFNAME_MAX];
+
+	if (is_oid_ref)
+		cl_git_pass(git_reference__normalize_name_oid(buffer_out, sizeof(buffer_out), input_refname));
+	else
+		cl_git_pass(git_reference__normalize_name(buffer_out, sizeof(buffer_out), input_refname));
+
+   if (expected_refname)
+	   cl_assert(0 == strcmp(buffer_out, expected_refname));
+}
+
+static void ensure_refname_invalid(int is_oid_ref, const char *input_refname)
+{
+	char buffer_out[GIT_REFNAME_MAX];
+
+   if (is_oid_ref)
+      cl_git_fail(git_reference__normalize_name_oid(buffer_out, sizeof(buffer_out), input_refname));
+   else
+      cl_git_fail(git_reference__normalize_name(buffer_out, sizeof(buffer_out), input_refname));
+}
+
+#define OID_REF 1
+#define SYM_REF 0
+
+
+
+void test_refs_normalize__direct(void)
+{
+   // normalize a direct (OID) reference name
+	ensure_refname_invalid(OID_REF, "a");
+	ensure_refname_invalid(OID_REF, "");
+	ensure_refname_invalid(OID_REF, "refs/heads/a/");
+	ensure_refname_invalid(OID_REF, "refs/heads/a.");
+	ensure_refname_invalid(OID_REF, "refs/heads/a.lock");
+	ensure_refname_normalized(OID_REF, "refs/dummy/a", NULL);
+	ensure_refname_normalized(OID_REF, "refs/stash", NULL);
+	ensure_refname_normalized(OID_REF, "refs/tags/a", "refs/tags/a");
+	ensure_refname_normalized(OID_REF, "refs/heads/a/b", "refs/heads/a/b");
+	ensure_refname_normalized(OID_REF, "refs/heads/a./b", "refs/heads/a./b");
+	ensure_refname_invalid(OID_REF, "refs/heads/foo?bar");
+	ensure_refname_invalid(OID_REF, "refs/heads\foo");
+	ensure_refname_normalized(OID_REF, "refs/heads/v@ation", "refs/heads/v@ation");
+	ensure_refname_normalized(OID_REF, "refs///heads///a", "refs/heads/a");
+	ensure_refname_invalid(OID_REF, "refs/heads/.a/b");
+	ensure_refname_invalid(OID_REF, "refs/heads/foo/../bar");
+	ensure_refname_invalid(OID_REF, "refs/heads/foo..bar");
+	ensure_refname_invalid(OID_REF, "refs/heads/./foo");
+	ensure_refname_invalid(OID_REF, "refs/heads/v@{ation");
+}
+
+void test_refs_normalize__symbolic(void)
+{
+   // normalize a symbolic reference name
+	ensure_refname_normalized(SYM_REF, "a", "a");
+	ensure_refname_normalized(SYM_REF, "a/b", "a/b");
+	ensure_refname_normalized(SYM_REF, "refs///heads///a", "refs/heads/a");
+	ensure_refname_invalid(SYM_REF, "");
+	ensure_refname_invalid(SYM_REF, "heads\foo");
+}
+
+/* Ported from JGit, BSD licence.
+ * See https://github.com/spearce/JGit/commit/e4bf8f6957bbb29362575d641d1e77a02d906739 */
+void test_refs_normalize__jgit_suite(void)
+{
+   // tests borrowed from JGit
+
+/* EmptyString */
+	ensure_refname_invalid(SYM_REF, "");
+	ensure_refname_invalid(SYM_REF, "/");
+
+/* MustHaveTwoComponents */
+	ensure_refname_invalid(OID_REF, "master");
+	ensure_refname_normalized(SYM_REF, "heads/master", "heads/master");
+
+/* ValidHead */
+
+	ensure_refname_normalized(SYM_REF, "refs/heads/master", "refs/heads/master");
+	ensure_refname_normalized(SYM_REF, "refs/heads/pu", "refs/heads/pu");
+	ensure_refname_normalized(SYM_REF, "refs/heads/z", "refs/heads/z");
+	ensure_refname_normalized(SYM_REF, "refs/heads/FoO", "refs/heads/FoO");
+
+/* ValidTag */
+	ensure_refname_normalized(SYM_REF, "refs/tags/v1.0", "refs/tags/v1.0");
+
+/* NoLockSuffix */
+	ensure_refname_invalid(SYM_REF, "refs/heads/master.lock");
+
+/* NoDirectorySuffix */
+	ensure_refname_invalid(SYM_REF, "refs/heads/master/");
+
+/* NoSpace */
+	ensure_refname_invalid(SYM_REF, "refs/heads/i haz space");
+
+/* NoAsciiControlCharacters */
+	{
+		char c;
+		char buffer[GIT_REFNAME_MAX];
+		for (c = '\1'; c < ' '; c++) {
+			strncpy(buffer, "refs/heads/mast", 15);
+			strncpy(buffer + 15, (const char *)&c, 1);
+			strncpy(buffer + 16, "er", 2);
+			buffer[18 - 1] = '\0';
+			ensure_refname_invalid(SYM_REF, buffer);
+		}
+	}
+
+/* NoBareDot */
+	ensure_refname_invalid(SYM_REF, "refs/heads/.");
+	ensure_refname_invalid(SYM_REF, "refs/heads/..");
+	ensure_refname_invalid(SYM_REF, "refs/heads/./master");
+	ensure_refname_invalid(SYM_REF, "refs/heads/../master");
+
+/* NoLeadingOrTrailingDot */
+	ensure_refname_invalid(SYM_REF, ".");
+	ensure_refname_invalid(SYM_REF, "refs/heads/.bar");
+	ensure_refname_invalid(SYM_REF, "refs/heads/..bar");
+	ensure_refname_invalid(SYM_REF, "refs/heads/bar.");
+
+/* ContainsDot */
+	ensure_refname_normalized(SYM_REF, "refs/heads/m.a.s.t.e.r", "refs/heads/m.a.s.t.e.r");
+	ensure_refname_invalid(SYM_REF, "refs/heads/master..pu");
+
+/* NoMagicRefCharacters */
+	ensure_refname_invalid(SYM_REF, "refs/heads/master^");
+	ensure_refname_invalid(SYM_REF, "refs/heads/^master");
+	ensure_refname_invalid(SYM_REF, "^refs/heads/master");
+
+	ensure_refname_invalid(SYM_REF, "refs/heads/master~");
+	ensure_refname_invalid(SYM_REF, "refs/heads/~master");
+	ensure_refname_invalid(SYM_REF, "~refs/heads/master");
+
+	ensure_refname_invalid(SYM_REF, "refs/heads/master:");
+	ensure_refname_invalid(SYM_REF, "refs/heads/:master");
+	ensure_refname_invalid(SYM_REF, ":refs/heads/master");
+
+/* ShellGlob */
+	ensure_refname_invalid(SYM_REF, "refs/heads/master?");
+	ensure_refname_invalid(SYM_REF, "refs/heads/?master");
+	ensure_refname_invalid(SYM_REF, "?refs/heads/master");
+
+	ensure_refname_invalid(SYM_REF, "refs/heads/master[");
+	ensure_refname_invalid(SYM_REF, "refs/heads/[master");
+	ensure_refname_invalid(SYM_REF, "[refs/heads/master");
+
+	ensure_refname_invalid(SYM_REF, "refs/heads/master*");
+	ensure_refname_invalid(SYM_REF, "refs/heads/*master");
+	ensure_refname_invalid(SYM_REF, "*refs/heads/master");
+
+/* ValidSpecialCharacters */
+	ensure_refname_normalized(SYM_REF, "refs/heads/!", "refs/heads/!");
+	ensure_refname_normalized(SYM_REF, "refs/heads/\"", "refs/heads/\"");
+	ensure_refname_normalized(SYM_REF, "refs/heads/#", "refs/heads/#");
+	ensure_refname_normalized(SYM_REF, "refs/heads/$", "refs/heads/$");
+	ensure_refname_normalized(SYM_REF, "refs/heads/%", "refs/heads/%");
+	ensure_refname_normalized(SYM_REF, "refs/heads/&", "refs/heads/&");
+	ensure_refname_normalized(SYM_REF, "refs/heads/'", "refs/heads/'");
+	ensure_refname_normalized(SYM_REF, "refs/heads/(", "refs/heads/(");
+	ensure_refname_normalized(SYM_REF, "refs/heads/)", "refs/heads/)");
+	ensure_refname_normalized(SYM_REF, "refs/heads/+", "refs/heads/+");
+	ensure_refname_normalized(SYM_REF, "refs/heads/,", "refs/heads/,");
+	ensure_refname_normalized(SYM_REF, "refs/heads/-", "refs/heads/-");
+	ensure_refname_normalized(SYM_REF, "refs/heads/;", "refs/heads/;");
+	ensure_refname_normalized(SYM_REF, "refs/heads/<", "refs/heads/<");
+	ensure_refname_normalized(SYM_REF, "refs/heads/=", "refs/heads/=");
+	ensure_refname_normalized(SYM_REF, "refs/heads/>", "refs/heads/>");
+	ensure_refname_normalized(SYM_REF, "refs/heads/@", "refs/heads/@");
+	ensure_refname_normalized(SYM_REF, "refs/heads/]", "refs/heads/]");
+	ensure_refname_normalized(SYM_REF, "refs/heads/_", "refs/heads/_");
+	ensure_refname_normalized(SYM_REF, "refs/heads/`", "refs/heads/`");
+	ensure_refname_normalized(SYM_REF, "refs/heads/{", "refs/heads/{");
+	ensure_refname_normalized(SYM_REF, "refs/heads/|", "refs/heads/|");
+	ensure_refname_normalized(SYM_REF, "refs/heads/}", "refs/heads/}");
+
+	// This is valid on UNIX, but not on Windows
+	// hence we make in invalid due to non-portability
+	//
+	ensure_refname_invalid(SYM_REF, "refs/heads/\\");
+
+/* UnicodeNames */
+	/*
+	 * Currently this fails.
+	 * ensure_refname_normalized(SYM_REF, "refs/heads/\u00e5ngstr\u00f6m", "refs/heads/\u00e5ngstr\u00f6m");
+	 */
+
+/* RefLogQueryIsValidRef */
+	ensure_refname_invalid(SYM_REF, "refs/heads/master@{1}");
+	ensure_refname_invalid(SYM_REF, "refs/heads/master@{1.hour.ago}");
+}

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

@@ -0,0 +1,136 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+static const char *ref_name = "refs/heads/other";
+static const char *ref_master_name = "refs/heads/master";
+static const char *ref_branch_name = "refs/heads/branch";
+static const char *ref_test_name = "refs/heads/test";
+
+static git_repository *g_repo;
+
+void test_refs_overwrite__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_overwrite__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_overwrite__symbolic(void)
+{
+   // Overwrite an existing symbolic reference
+	git_reference *ref, *branch_ref;
+
+	/* The target needds to exist and we need to check the name has changed */
+	cl_git_pass(git_reference_create_symbolic(&branch_ref, g_repo, ref_branch_name, ref_master_name, 0));
+	cl_git_pass(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_branch_name, 0));
+	git_reference_free(ref);
+
+	/* Ensure it points to the right place*/
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC);
+	cl_assert_equal_s(git_reference_target(ref), ref_branch_name);
+	git_reference_free(ref);
+
+	/* Ensure we can't create it unless we force it to */
+	cl_git_fail(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_master_name, 0));
+	cl_git_pass(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_master_name, 1));
+	git_reference_free(ref);
+
+	/* Ensure it points to the right place */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC);
+	cl_assert_equal_s(git_reference_target(ref), ref_master_name);
+
+	git_reference_free(ref);
+	git_reference_free(branch_ref);
+}
+
+void test_refs_overwrite__object_id(void)
+{
+   // Overwrite an existing object id reference
+	git_reference *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));
+	git_reference_free(ref);
+
+	/* Create it */
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, ref_name, &id, 0));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_test_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_OID);
+	git_oid_cpy(&id, git_reference_oid(ref));
+	git_reference_free(ref);
+
+	/* Ensure we can't overwrite unless we force it */
+	cl_git_fail(git_reference_create_oid(&ref, g_repo, ref_name, &id, 0));
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, ref_name, &id, 1));
+	git_reference_free(ref);
+
+	/* Ensure it has been overwritten */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name));
+	cl_assert(!git_oid_cmp(&id, git_reference_oid(ref)));
+
+	git_reference_free(ref);
+}
+
+void test_refs_overwrite__object_id_with_symbolic(void)
+{
+   // Overwrite an existing object id reference with a symbolic one
+	git_reference *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));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, ref_name, &id, 0));
+	git_reference_free(ref);
+	cl_git_fail(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_master_name, 0));
+	cl_git_pass(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_master_name, 1));
+	git_reference_free(ref);
+
+	/* Ensure it points to the right place */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_SYMBOLIC);
+	cl_assert_equal_s(git_reference_target(ref), ref_master_name);
+
+	git_reference_free(ref);
+}
+
+void test_refs_overwrite__symbolic_with_object_id(void)
+{
+   // Overwrite an existing symbolic reference with an object id one
+	git_reference *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));
+	git_reference_free(ref);
+
+	/* Create the symbolic ref */
+	cl_git_pass(git_reference_create_symbolic(&ref, g_repo, ref_name, ref_master_name, 0));
+	git_reference_free(ref);
+	/* It shouldn't overwrite unless we tell it to */
+	cl_git_fail(git_reference_create_oid(&ref, g_repo, ref_name, &id, 0));
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, ref_name, &id, 1));
+	git_reference_free(ref);
+
+	/* Ensure it points to the right place */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_name));
+	cl_assert(git_reference_type(ref) & GIT_REF_OID);
+	cl_assert(!git_oid_cmp(git_reference_oid(ref), &id));
+
+	git_reference_free(ref);
+}

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

@@ -0,0 +1,67 @@
+#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 git_repository *g_repo;
+
+void test_refs_pack__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_pack__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_pack__empty(void)
+{
+   // create a packfile for an empty folder
+	git_buf temp_path = GIT_BUF_INIT;
+
+	cl_git_pass(git_buf_join_n(&temp_path, '/', 3, g_repo->path_repository, GIT_REFS_HEADS_DIR, "empty_dir"));
+	cl_git_pass(git_futils_mkdir_r(temp_path.ptr, NULL, GIT_REFS_DIR_MODE));
+	git_buf_free(&temp_path);
+
+	cl_git_pass(git_reference_packall(g_repo));
+}
+
+void test_refs_pack__loose(void)
+{
+   // create a packfile from all the loose rn a repo
+	git_reference *reference;
+	git_buf temp_path = GIT_BUF_INIT;
+
+	/* Ensure a known loose ref can be looked up */
+	cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name));
+	cl_assert(git_reference_is_packed(reference) == 0);
+	cl_assert_equal_s(reference->name, loose_tag_ref_name);
+	git_reference_free(reference);
+
+	/*
+	 * We are now trying to pack also a loose reference
+	 * called `points_to_blob`, to make sure we can properly
+	 * pack weak tags
+	 */
+	cl_git_pass(git_reference_packall(g_repo));
+
+	/* Ensure the packed-refs file exists */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, GIT_PACKEDREFS_FILE));
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	/* Ensure the known ref can still be looked up but is now packed */
+	cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name));
+	cl_assert(git_reference_is_packed(reference));
+	cl_assert_equal_s(reference->name, loose_tag_ref_name);
+
+	/* Ensure the known ref has been removed from the loose folder structure */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, loose_tag_ref_name));
+	cl_assert(!git_path_exists(temp_path.ptr));
+
+	git_reference_free(reference);
+	git_buf_free(&temp_path);
+}

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

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