thodg/libgit2/tests/t10-refs.c

• Show log

  Commit

• Hash : e7be57a9
  Author :
  Date : 2011-08-15T18:56:27
  

  reflog: assimilate reflog API to return git_oid's Rather than returning the OIDs out of the reflog as string return them as git_oid. Signed-off-by: schu <schu-github@schulog.org>

Download

• tests/t10-refs.c

• /*
   * 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 "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";
  
  BEGIN_TEST(readtag0, "lookup a loose tag reference")
  	git_repository *repo;
  	git_reference *reference;
  	git_object *object;
  	char ref_name_from_tag_name[GIT_REFNAME_MAX];
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
  	must_be_true(reference->type & GIT_REF_OID);
  	must_be_true((reference->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
  
  	must_pass(git_object_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
  	must_be_true(object != NULL);
  	must_be_true(git_object_type(object) == GIT_OBJ_TAG);
  
  	/* Ensure the name of the tag matches the name of the reference */
  	git_path_join(ref_name_from_tag_name, GIT_REFS_TAGS_DIR, git_tag_name((git_tag *)object));
  	must_be_true(strcmp(ref_name_from_tag_name, loose_tag_ref_name) == 0);
  
  	git_object_close(object);
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(readtag1, "lookup a loose tag reference that doesn't exist")
  	git_repository *repo;
  	git_reference *reference;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  	must_fail(git_reference_lookup(&reference, repo, non_existing_tag_ref_name));
  
  	git_repository_free(repo);
  END_TEST
  
  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 = "be3563ae3f795b2b4353bcce3a527ad0a4f7f644";
  
  BEGIN_TEST(readsym0, "lookup a symbolic reference")
  	git_repository *repo;
  	git_reference *reference, *resolved_ref;
  	git_object *object;
  	git_oid id;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE));
  	must_be_true(reference->type & GIT_REF_SYMBOLIC);
  	must_be_true((reference->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(reference->name, GIT_HEAD_FILE) == 0);
  
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	must_be_true(resolved_ref->type == GIT_REF_OID);
  
  	must_pass(git_object_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
  	must_be_true(object != NULL);
  	must_be_true(git_object_type(object) == GIT_OBJ_COMMIT);
  
  	git_oid_fromstr(&id, current_master_tip);
  	must_be_true(git_oid_cmp(&id, git_object_id(object)) == 0);
  
  	git_object_close(object);
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(readsym1, "lookup a nested symbolic reference")
  	git_repository *repo;
  	git_reference *reference, *resolved_ref;
  	git_object *object;
  	git_oid id;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&reference, repo, head_tracker_sym_ref_name));
  	must_be_true(reference->type & GIT_REF_SYMBOLIC);
  	must_be_true((reference->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(reference->name, head_tracker_sym_ref_name) == 0);
  
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	must_be_true(resolved_ref->type == GIT_REF_OID);
  
  	must_pass(git_object_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
  	must_be_true(object != NULL);
  	must_be_true(git_object_type(object) == GIT_OBJ_COMMIT);
  
  	git_oid_fromstr(&id, current_master_tip);
  	must_be_true(git_oid_cmp(&id, git_object_id(object)) == 0);
  
  	git_object_close(object);
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(readsym2, "lookup the HEAD and resolve the master branch")
  	git_repository *repo;
  	git_reference *reference, *resolved_ref, *comp_base_ref;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&reference, repo, head_tracker_sym_ref_name));
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	comp_base_ref = resolved_ref;
  
  	must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE));
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	must_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
  
  	must_pass(git_reference_lookup(&reference, repo, current_head_target));
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	must_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
  
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(readsym3, "lookup the master branch and then the HEAD")
  	git_repository *repo;
  	git_reference *reference, *master_ref, *resolved_ref;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&master_ref, repo, current_head_target));
  	must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE));
  
  	must_pass(git_reference_resolve(&resolved_ref, reference));
  	must_pass(git_oid_cmp(git_reference_oid(master_ref), git_reference_oid(resolved_ref)));
  
  	git_repository_free(repo);
  END_TEST
  
  static const char *packed_head_name = "refs/heads/packed";
  static const char *packed_test_head_name = "refs/heads/packed-test";
  
  BEGIN_TEST(readpacked0, "lookup a packed reference")
  	git_repository *repo;
  	git_reference *reference;
  	git_object *object;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&reference, repo, packed_head_name));
  	must_be_true(reference->type & GIT_REF_OID);
  	must_be_true((reference->type & GIT_REF_PACKED) != 0);
  	must_be_true(strcmp(reference->name, packed_head_name) == 0);
  
  	must_pass(git_object_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
  	must_be_true(object != NULL);
  	must_be_true(git_object_type(object) == GIT_OBJ_COMMIT);
  
  	git_object_close(object);
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(readpacked1, "assure that a loose reference is looked up before a packed reference")
  	git_repository *repo;
  	git_reference *reference;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  	must_pass(git_reference_lookup(&reference, repo, packed_head_name));
  	must_pass(git_reference_lookup(&reference, repo, packed_test_head_name));
  	must_be_true(reference->type & GIT_REF_OID);
  	must_be_true((reference->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(reference->name, packed_test_head_name) == 0);
  
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(create0, "create a new symbolic reference")
  	git_reference *new_reference, *looked_up_ref, *resolved_ref;
  	git_repository *repo, *repo2;
  	git_oid id;
  	char ref_path[GIT_PATH_MAX];
  
  	const char *new_head_tracker = "another-head-tracker";
  
  	git_oid_fromstr(&id, current_master_tip);
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Retrieve the physical path to the symbolic ref for further cleaning */
  	git_path_join(ref_path, repo->path_repository, new_head_tracker);
  
  	/* Create and write the new symbolic reference */
  	must_pass(git_reference_create_symbolic(&new_reference, repo, new_head_tracker, current_head_target, 0));
  
  	/* Ensure the reference can be looked-up... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, new_head_tracker));
  	must_be_true(looked_up_ref->type & GIT_REF_SYMBOLIC);
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(looked_up_ref->name, new_head_tracker) == 0);
  
  	/* ...peeled.. */
  	must_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
  	must_be_true(resolved_ref->type == GIT_REF_OID);
  
  	/* ...and that it points to the current master tip */
  	must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
  
  	git_repository_free(repo);
  
  	/* Similar test with a fresh new repository */
  	must_pass(git_repository_open(&repo2, TEMP_REPO_FOLDER));
  
  	must_pass(git_reference_lookup(&looked_up_ref, repo2, new_head_tracker));
  	must_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
  	must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
  
  	close_temp_repo(repo2);
  END_TEST
  
  BEGIN_TEST(create1, "create a deep symbolic reference")
  	git_reference *new_reference, *looked_up_ref, *resolved_ref;
  	git_repository *repo;
  	git_oid id;
  	char ref_path[GIT_PATH_MAX];
  
  	const char *new_head_tracker = "deep/rooted/tracker";
  
  	git_oid_fromstr(&id, current_master_tip);
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	git_path_join(ref_path, repo->path_repository, new_head_tracker);
  	must_pass(git_reference_create_symbolic(&new_reference, repo, new_head_tracker, current_head_target, 0));
  	must_pass(git_reference_lookup(&looked_up_ref, repo, new_head_tracker));
  	must_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
  	must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(create2, "create a new OID reference")
  	git_reference *new_reference, *looked_up_ref;
  	git_repository *repo, *repo2;
  	git_oid id;
  	char ref_path[GIT_PATH_MAX];
  
  	const char *new_head = "refs/heads/new-head";
  
  	git_oid_fromstr(&id, current_master_tip);
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Retrieve the physical path to the symbolic ref for further cleaning */
  	git_path_join(ref_path, repo->path_repository, new_head);
  
  	/* Create and write the new object id reference */
  	must_pass(git_reference_create_oid(&new_reference, repo, new_head, &id, 0));
  
  	/* Ensure the reference can be looked-up... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, new_head));
  	must_be_true(looked_up_ref->type & GIT_REF_OID);
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(looked_up_ref->name, new_head) == 0);
  
  	/* ...and that it points to the current master tip */
  	must_be_true(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0);
  
  	git_repository_free(repo);
  
  	/* Similar test with a fresh new repository */
  	must_pass(git_repository_open(&repo2, TEMP_REPO_FOLDER));
  
  	must_pass(git_reference_lookup(&looked_up_ref, repo2, new_head));
  	must_be_true(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0);
  
  	close_temp_repo(repo2);
  END_TEST
  
  BEGIN_TEST(create3, "Can not create a new OID reference which targets at an unknown id")
  	git_reference *new_reference, *looked_up_ref;
  	git_repository *repo;
  	git_oid id;
  
  	const char *new_head = "refs/heads/new-head";
  
  	git_oid_fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644");
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  
  	/* Create and write the new object id reference */
  	must_fail(git_reference_create_oid(&new_reference, repo, new_head, &id, 0));
  
  	/* Ensure the reference can't be looked-up... */
  	must_fail(git_reference_lookup(&looked_up_ref, repo, new_head));
  
  	git_repository_free(repo);
  END_TEST
  
  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";
  BEGIN_TEST(overwrite0, "Overwrite an existing symbolic reference")
  	git_reference *ref, *branch_ref;
  	git_repository *repo;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* The target needds to exist and we need to check the name has changed */
  	must_pass(git_reference_create_symbolic(&branch_ref, repo, ref_branch_name, ref_master_name, 0));
  	must_pass(git_reference_create_symbolic(&ref, repo, ref_name, ref_branch_name, 0));
  	/* Ensure it points to the right place*/
  	must_pass(git_reference_lookup(&ref, repo, ref_name));
  	must_be_true(git_reference_type(ref) & GIT_REF_SYMBOLIC);
  	must_be_true(!strcmp(git_reference_target(ref), ref_branch_name));
  
  	/* Ensure we can't create it unless we force it to */
  	must_fail(git_reference_create_symbolic(&ref, repo, ref_name, ref_master_name, 0));
  	must_pass(git_reference_create_symbolic(&ref, repo, ref_name, ref_master_name, 1));
  
  	/* Ensure it points to the right place */
  	must_pass(git_reference_lookup(&ref, repo, ref_name));
  	must_be_true(git_reference_type(ref) & GIT_REF_SYMBOLIC);
  	must_be_true(!strcmp(git_reference_target(ref), ref_master_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(overwrite1, "Overwrite an existing object id reference")
  	git_reference *ref;
  	git_repository *repo;
  	git_oid id;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_master_name));
  	must_be_true(ref->type & GIT_REF_OID);
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	/* Create it */
  	must_pass(git_reference_create_oid(&ref, repo, ref_name, &id, 0));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_test_name));
  	must_be_true(ref->type & GIT_REF_OID);
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	/* Ensure we can't overwrite unless we force it */
  	must_fail(git_reference_create_oid(&ref, repo, ref_name, &id, 0));
  	must_pass(git_reference_create_oid(&ref, repo, ref_name, &id, 1));
  
  	/* Ensure it has been overwritten */
  	must_pass(git_reference_lookup(&ref, repo, ref_name));
  	must_be_true(!git_oid_cmp(&id, git_reference_oid(ref)));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(overwrite2, "Overwrite an existing object id reference with a symbolic one")
  	git_reference *ref;
  	git_repository *repo;
  	git_oid id;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_master_name));
  	must_be_true(ref->type & GIT_REF_OID);
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	must_pass(git_reference_create_oid(&ref, repo, ref_name, &id, 0));
  	must_fail(git_reference_create_symbolic(&ref, repo, ref_name, ref_master_name, 0));
  	must_pass(git_reference_create_symbolic(&ref, repo, ref_name, ref_master_name, 1));
  
  	/* Ensure it points to the right place */
  	must_pass(git_reference_lookup(&ref, repo, ref_name));
  	must_be_true(git_reference_type(ref) & GIT_REF_SYMBOLIC);
  	must_be_true(!strcmp(git_reference_target(ref), ref_master_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(overwrite3, "Overwrite an existing symbolic reference with an object id one")
  	git_reference *ref;
  	git_repository *repo;
  	git_oid id;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_master_name));
  	must_be_true(ref->type & GIT_REF_OID);
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	/* Create the symbolic ref */
  	must_pass(git_reference_create_symbolic(&ref, repo, ref_name, ref_master_name, 0));
  	/* It shouldn't overwrite unless we tell it to */
  	must_fail(git_reference_create_oid(&ref, repo, ref_name, &id, 0));
  	must_pass(git_reference_create_oid(&ref, repo, ref_name, &id, 1));
  
  	/* Ensure it points to the right place */
  	must_pass(git_reference_lookup(&ref, repo, ref_name));
  	must_be_true(git_reference_type(ref) & GIT_REF_OID);
  	must_be_true(!git_oid_cmp(git_reference_oid(ref), &id));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(pack0, "create a packfile for an empty folder")
  	git_repository *repo;
  	char temp_path[GIT_PATH_MAX];
  	const int mode = 0755; /* or 0777 ? */
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	git_path_join_n(temp_path, 3, repo->path_repository, GIT_REFS_HEADS_DIR, "empty_dir");
  	must_pass(git_futils_mkdir_r(temp_path, mode));
  
  	must_pass(git_reference_packall(repo));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
  	git_repository *repo;
  	git_reference *reference;
  	char temp_path[GIT_PATH_MAX];
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Ensure a known loose ref can be looked up */
  	must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
  	must_be_true((reference->type & GIT_REF_PACKED) == 0);
  	must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
  
  	/*
  	 * We are now trying to pack also a loose reference
  	 * called `points_to_blob`, to make sure we can properly
  	 * pack weak tags
  	 */
  	must_pass(git_reference_packall(repo));
  
  	/* Ensure the packed-refs file exists */
  	git_path_join(temp_path, repo->path_repository, GIT_PACKEDREFS_FILE);
  	must_pass(git_futils_exists(temp_path));
  
  	/* Ensure the known ref can still be looked up but is now packed */
  	must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
  	must_be_true((reference->type & GIT_REF_PACKED) != 0);
  	must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
  
  	/* Ensure the known ref has been removed from the loose folder structure */
  	git_path_join(temp_path, repo->path_repository, loose_tag_ref_name);
  	must_pass(!git_futils_exists(temp_path));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename0, "rename a loose reference")
  	git_reference *looked_up_ref, *another_looked_up_ref;
  	git_repository *repo;
  	char temp_path[GIT_PATH_MAX];
  	const char *new_name = "refs/tags/Nemo/knows/refs.kung-fu";
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Ensure the ref doesn't exist on the file system */
  	git_path_join(temp_path, repo->path_repository, new_name);
  	must_pass(!git_futils_exists(temp_path));
  
  	/* Retrieval of the reference to rename */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, loose_tag_ref_name));
  
  	/* ... which is indeed loose */
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* Now that the reference is renamed... */
  	must_pass(git_reference_rename(looked_up_ref, new_name, 0));
  	must_be_true(!strcmp(looked_up_ref->name, new_name));
  
  	/* ...It can't be looked-up with the old name... */
  	must_fail(git_reference_lookup(&another_looked_up_ref, repo, loose_tag_ref_name));
  
  	/* ...but the new name works ok... */
  	must_pass(git_reference_lookup(&another_looked_up_ref, repo, new_name));
  	must_be_true(!strcmp(another_looked_up_ref->name, new_name));
  
  	/* .. the ref is still loose... */
  	must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* ...and the ref can be found in the file system */
  	git_path_join(temp_path, repo->path_repository, new_name);
  	must_pass(git_futils_exists(temp_path));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
  	git_reference *looked_up_ref, *another_looked_up_ref;
  	git_repository *repo;
  	char temp_path[GIT_PATH_MAX];
  	const char *brand_new_name = "refs/heads/brand_new_name";
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Ensure the ref doesn't exist on the file system */
  	git_path_join(temp_path, repo->path_repository, packed_head_name);
  	must_pass(!git_futils_exists(temp_path));
  
  	/* The reference can however be looked-up... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
  
  	/* .. and it's packed */
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) != 0);
  
  	/* Now that the reference is renamed... */
  	must_pass(git_reference_rename(looked_up_ref, brand_new_name, 0));
  	must_be_true(!strcmp(looked_up_ref->name, brand_new_name));
  
  	/* ...It can't be looked-up with the old name... */
  	must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_head_name));
  
  	/* ...but the new name works ok... */
  	must_pass(git_reference_lookup(&another_looked_up_ref, repo, brand_new_name));
  	must_be_true(!strcmp(another_looked_up_ref->name, brand_new_name));
  
  	/* .. the ref is no longer packed... */
  	must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* ...and the ref now happily lives in the file system */
  	git_path_join(temp_path, repo->path_repository, brand_new_name);
  	must_pass(git_futils_exists(temp_path));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename2, "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_repository *repo;
  	char temp_path[GIT_PATH_MAX];
  	const char *brand_new_name = "refs/heads/brand_new_name";
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Ensure the other reference exists on the file system */
  	git_path_join(temp_path, repo->path_repository, packed_test_head_name);
  	must_pass(git_futils_exists(temp_path));
  
  	/* Lookup the other reference */
  	must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
  
  	/* Ensure it's loose */
  	must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* Lookup the reference to rename */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
  
  	/* Ensure it's packed */
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) != 0);
  
  	/* Now that the reference is renamed... */
  	must_pass(git_reference_rename(looked_up_ref, brand_new_name, 0));
  
  	/* Lookup the other reference */
  	must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
  
  	/* Ensure it's loose */
  	must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* Ensure the other ref still exists on the file system */
  	must_pass(git_futils_exists(temp_path));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename3, "can not rename a reference with the name of an existing reference")
  	git_reference *looked_up_ref;
  	git_repository *repo;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* An existing reference... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
  
  	/* Can not be renamed to the name of another existing reference. */
  	must_fail(git_reference_rename(looked_up_ref, packed_test_head_name, 0));
  
  	/* Failure to rename it hasn't corrupted its state */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
  	must_be_true(!strcmp(looked_up_ref->name, packed_head_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename4, "can not rename a reference with an invalid name")
  	git_reference *looked_up_ref;
  	git_repository *repo;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* An existing oid reference... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
  
  	/* Can not be renamed with an invalid name. */
  	must_fail(git_reference_rename(looked_up_ref, "Hello! I'm a very invalid name.", 0));
  
  	/* Can not be renamed outside of the refs hierarchy. */
  	must_fail(git_reference_rename(looked_up_ref, "i-will-sudo-you", 0));
  
  	/* Failure to rename it hasn't corrupted its state */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
  	must_be_true(!strcmp(looked_up_ref->name, packed_test_head_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename5, "can force-rename a packed reference with the name of an existing loose and packed reference")
  	git_reference *looked_up_ref;
  	git_repository *repo;
  	git_oid oid;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* An existing reference... */
  	must_pass(git_reference_lookup(&looked_up_ref, 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. */
  	must_pass(git_reference_rename(looked_up_ref, packed_test_head_name, 1));
  
  	/* Check we actually renamed it */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
  	must_be_true(!strcmp(looked_up_ref->name, packed_test_head_name));
  	must_be_true(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref)));
  
  	/* And that the previous one doesn't exist any longer */
  	must_fail(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(rename6, "can force-rename a loose reference with the name of an existing loose reference")
  	git_reference *looked_up_ref;
  	git_repository *repo;
  	git_oid oid;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* An existing reference... */
  	must_pass(git_reference_lookup(&looked_up_ref, 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. */
  	must_pass(git_reference_rename(looked_up_ref, "refs/heads/test", 1));
  
  	/* Check we actually renamed it */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, "refs/heads/test"));
  	must_be_true(!strcmp(looked_up_ref->name,  "refs/heads/test"));
  	must_be_true(!git_oid_cmp(&oid, git_reference_oid(looked_up_ref)));
  
  	/* And that the previous one doesn't exist any longer */
  	must_fail(git_reference_lookup(&looked_up_ref, repo, "refs/heads/br2"));
  
  	close_temp_repo(repo);
  END_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";
  
  BEGIN_TEST(rename7, "can not overwrite name of existing reference")
  	git_reference *ref, *ref_one, *ref_one_new, *ref_two;
  	git_repository *repo;
  	git_oid id;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_master_name));
  	must_be_true(ref->type & GIT_REF_OID);
  
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	/* Create loose references */
  	must_pass(git_reference_create_oid(&ref_one, repo, ref_one_name, &id, 0));
  	must_pass(git_reference_create_oid(&ref_two, repo, ref_two_name, &id, 0));
  
  	/* Pack everything */
  	must_pass(git_reference_packall(repo));
  
  	/* Attempt to create illegal reference */
  	must_fail(git_reference_create_oid(&ref_one_new, repo, ref_one_name_new, &id, 0));
  
  	/* Illegal reference couldn't be created so this is supposed to fail */
  	must_fail(git_reference_lookup(&ref_one_new, repo, ref_one_name_new));
  
  	close_temp_repo(repo);
  END_TEST
  
  static const char *ref_two_name_new = "refs/heads/two/two";
  
  BEGIN_TEST(rename8, "can be renamed to a new name prefixed with the old name")
  	git_reference *ref, *ref_two, *looked_up_ref;
  	git_repository *repo;
  	git_oid id;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	must_pass(git_reference_lookup(&ref, repo, ref_master_name));
  	must_be_true(ref->type & GIT_REF_OID);
  
  	git_oid_cpy(&id, git_reference_oid(ref));
  
  	/* Create loose references */
  	must_pass(git_reference_create_oid(&ref_two, repo, ref_two_name, &id, 0));
  
  	/* An existing reference... */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, ref_two_name));
  
  	/* Can be rename to a new name starting with the old name. */
  	must_pass(git_reference_rename(looked_up_ref, ref_two_name_new, 0));
  
  	/* Check we actually renamed it */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, ref_two_name_new));
  	must_be_true(!strcmp(looked_up_ref->name, ref_two_name_new));
  	must_fail(git_reference_lookup(&looked_up_ref, repo, ref_two_name));
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove both tracks in the filesystem")
  	git_reference *looked_up_ref, *another_looked_up_ref;
  	git_repository *repo;
  	char temp_path[GIT_PATH_MAX];
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Ensure the loose reference exists on the file system */
  	git_path_join(temp_path, repo->path_repository, packed_test_head_name);
  	must_pass(git_futils_exists(temp_path));
  
  	/* Lookup the reference */
  	must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
  
  	/* Ensure it's the loose version that has been found */
  	must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
  
  	/* Now that the reference is deleted... */
  	must_pass(git_reference_delete(looked_up_ref));
  
  	/* Looking up the reference once again should not retrieve it */
  	must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
  
  	/* Ensure the loose reference doesn't exist any longer on the file system */
  	must_pass(!git_futils_exists(temp_path));
  
  	close_temp_repo(repo);
  END_TEST
  
  static int ensure_refname_normalized(int is_oid_ref, const char *input_refname, const char *expected_refname)
  {
  	int error = GIT_SUCCESS;
  	char buffer_out[GIT_REFNAME_MAX];
  
  	if (is_oid_ref)
  		error = git_reference__normalize_name_oid(buffer_out, sizeof(buffer_out), input_refname);
  	else
  		error = git_reference__normalize_name(buffer_out, sizeof(buffer_out), input_refname);
  
  	if (error < GIT_SUCCESS)
  		return error;
  
  	if (expected_refname == NULL)
  		return error;
  
  	if (strcmp(buffer_out, expected_refname))
  		error = GIT_ERROR;
  
  	return error;
  }
  
  #define OID_REF 1
  #define SYM_REF 0
  
  BEGIN_TEST(normalize0, "normalize a direct (OID) reference name")
  	must_fail(ensure_refname_normalized(OID_REF, "a", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/a/", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/a.", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/a.lock", NULL));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/dummy/a", NULL));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/stash", NULL));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/tags/a", "refs/tags/a"));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/heads/a/b", "refs/heads/a/b"));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/heads/a./b", "refs/heads/a./b"));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/foo?bar", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads\foo", NULL));
  	must_pass(ensure_refname_normalized(OID_REF, "refs/heads/v@ation", "refs/heads/v@ation"));
  	must_pass(ensure_refname_normalized(OID_REF, "refs///heads///a", "refs/heads/a"));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/.a/b", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/foo/../bar", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/foo..bar", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/./foo", NULL));
  	must_fail(ensure_refname_normalized(OID_REF, "refs/heads/v@{ation", NULL));
  END_TEST
  
  BEGIN_TEST(normalize1, "normalize a symbolic reference name")
  	must_pass(ensure_refname_normalized(SYM_REF, "a", "a"));
  	must_pass(ensure_refname_normalized(SYM_REF, "a/b", "a/b"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs///heads///a", "refs/heads/a"));
  	must_fail(ensure_refname_normalized(SYM_REF, "", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "heads\foo", NULL));
  END_TEST
  
  /* Ported from JGit, BSD licence.
   * See https://github.com/spearce/JGit/commit/e4bf8f6957bbb29362575d641d1e77a02d906739 */
  BEGIN_TEST(normalize2, "tests borrowed from JGit")
  
  /* EmptyString */
  	must_fail(ensure_refname_normalized(SYM_REF, "", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "/", NULL));
  
  /* MustHaveTwoComponents */
  	must_fail(ensure_refname_normalized(OID_REF, "master", NULL));
  	must_pass(ensure_refname_normalized(SYM_REF, "heads/master", "heads/master"));
  
  /* ValidHead */
  
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/master", "refs/heads/master"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/pu", "refs/heads/pu"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/z", "refs/heads/z"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/FoO", "refs/heads/FoO"));
  
  /* ValidTag */
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/tags/v1.0", "refs/tags/v1.0"));
  
  /* NoLockSuffix */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master.lock", NULL));
  
  /* NoDirectorySuffix */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master/", NULL));
  
  /* NoSpace */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/i haz space", NULL));
  
  /* 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';
  			must_fail(ensure_refname_normalized(SYM_REF, buffer, NULL));
  		}
  	}
  
  /* NoBareDot */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/.", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/..", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/./master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/../master", NULL));
  
  /* NoLeadingOrTrailingDot */
  	must_fail(ensure_refname_normalized(SYM_REF, ".", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/.bar", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/..bar", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/bar.", NULL));
  
  /* ContainsDot */
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/m.a.s.t.e.r", "refs/heads/m.a.s.t.e.r"));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master..pu", NULL));
  
  /* NoMagicRefCharacters */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master^", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/^master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "^refs/heads/master", NULL));
  
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master~", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/~master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "~refs/heads/master", NULL));
  
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master:", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/:master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, ":refs/heads/master", NULL));
  
  /* ShellGlob */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master?", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/?master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "?refs/heads/master", NULL));
  
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master[", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/[master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "[refs/heads/master", NULL));
  
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master*", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/*master", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "*refs/heads/master", NULL));
  
  /* ValidSpecialCharacters */
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/!", "refs/heads/!"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/\"", "refs/heads/\""));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/#", "refs/heads/#"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/$", "refs/heads/$"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/%", "refs/heads/%"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/&", "refs/heads/&"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/'", "refs/heads/'"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/(", "refs/heads/("));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/)", "refs/heads/)"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/+", "refs/heads/+"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/,", "refs/heads/,"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/-", "refs/heads/-"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/;", "refs/heads/;"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/<", "refs/heads/<"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/=", "refs/heads/="));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/>", "refs/heads/>"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/@", "refs/heads/@"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/]", "refs/heads/]"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/_", "refs/heads/_"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/`", "refs/heads/`"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/{", "refs/heads/{"));
  	must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/|", "refs/heads/|"));
  	must_pass(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
  	//
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/\\", NULL));
  
  /* UnicodeNames */
  	/*
  	 * Currently this fails.
  	 * must_pass(ensure_refname_normalized(SYM_REF, "refs/heads/\u00e5ngstr\u00f6m", "refs/heads/\u00e5ngstr\u00f6m"));
  	 */
  
  /* RefLogQueryIsValidRef */
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master@{1}", NULL));
  	must_fail(ensure_refname_normalized(SYM_REF, "refs/heads/master@{1.hour.ago}", NULL));
  END_TEST
  
  BEGIN_TEST(list0, "try to list all the references in our test repo")
  	git_repository *repo;
  	git_strarray ref_list;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  	must_pass(git_reference_listall(&ref_list, repo, GIT_REF_LISTALL));
  
  	/*{
  		unsigned short i;
  		for (i = 0; i < ref_list.count; ++i)
  			printf("# %s\n", ref_list.strings[i]);
  	}*/
  
  	/* We have exactly 8 refs in total if we include the packed ones:
  	 * there is a reference that exists both in the packfile and as
  	 * loose, but we only list it once */
  	must_be_true(ref_list.count == 8);
  
  	git_strarray_free(&ref_list);
  	git_repository_free(repo);
  END_TEST
  
  BEGIN_TEST(list1, "try to list only the symbolic references")
  	git_repository *repo;
  	git_strarray ref_list;
  
  	must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
  	must_pass(git_reference_listall(&ref_list, repo, GIT_REF_SYMBOLIC));
  	must_be_true(ref_list.count == 0); /* no symrefs in the test repo */
  
  	git_strarray_free(&ref_list);
  	git_repository_free(repo);
  END_TEST
  
  static const char *new_ref = "refs/heads/test-reflog";
  #define commit_msg "commit: bla bla"
  
  static int assert_signature(git_signature *expected, git_signature *actual)
  {
  	if (actual == NULL)
  		return GIT_ERROR;
  
  	if (strcmp(expected->name, actual->name) != 0)
  		return GIT_ERROR;
  
  	if (strcmp(expected->email, actual->email) != 0)
  		return GIT_ERROR;
  
  	if (expected->when.offset != actual->when.offset)
  		return GIT_ERROR;
  
  	if (expected->when.time != actual->when.time)
  		return GIT_ERROR;
  
  	return GIT_SUCCESS;
  }
  
  BEGIN_TEST(reflog0, "write a reflog for a given reference and ensure it can be read back")
  	git_repository *repo, *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];
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Create a new branch pointing at the HEAD */
  	git_oid_fromstr(&oid, current_master_tip);
  	must_pass(git_reference_create_oid(&ref, repo, new_ref, &oid, 0));
  	must_pass(git_reference_lookup(&ref, repo, new_ref));
  
  	must_pass(git_signature_now(&committer, "foo", "foo@bar"));
  
  	must_pass(git_reflog_write(ref, NULL, committer, NULL));
  	must_fail(git_reflog_write(ref, NULL, committer, "no ancestor NULL for an existing reflog"));
  	must_fail(git_reflog_write(ref, NULL, committer, "no\nnewline"));
  	must_pass(git_reflog_write(ref, &oid, committer, commit_msg));
  
  	git_repository_free(repo);
  
  	/* Reopen a new instance of the repository */
  	must_pass(git_repository_open(&repo2, TEMP_REPO_FOLDER));
  
  	/* Lookup the preivously created branch */
  	must_pass(git_reference_lookup(&lookedup_ref, repo2, new_ref));
  
  	/* Read and parse the reflog for this branch */
  	must_pass(git_reflog_read(&reflog, lookedup_ref));
  	must_be_true(reflog->entries.length == 2);
  
  	entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 0);
  	must_pass(assert_signature(committer, entry->committer));
  	git_oid_to_string(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old);
  	must_be_true(strcmp("0000000000000000000000000000000000000000", oid_str) == 0);
  	git_oid_to_string(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur);
  	must_be_true(strcmp(current_master_tip, oid_str) == 0);
  	must_be_true(entry->msg == NULL);
  
  	entry = (git_reflog_entry *)git_vector_get(&reflog->entries, 1);
  	must_pass(assert_signature(committer, entry->committer));
  	git_oid_to_string(oid_str, GIT_OID_HEXSZ+1, &entry->oid_old);
  	must_be_true(strcmp(current_master_tip, oid_str) == 0);
  	git_oid_to_string(oid_str, GIT_OID_HEXSZ+1, &entry->oid_cur);
  	must_be_true(strcmp(current_master_tip, oid_str) == 0);
  	must_be_true(strcmp(commit_msg, entry->msg) == 0);
  
  	git_signature_free(committer);
  	git_reflog_free(reflog);
  	close_temp_repo(repo2);
  END_TEST
  
  BEGIN_TEST(reflog1, "avoid writing an obviously wrong reflog")
  	git_repository *repo;
  	git_reference *ref;
  	git_oid oid;
  	git_signature *committer;
  
  	must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
  
  	/* Create a new branch pointing at the HEAD */
  	git_oid_fromstr(&oid, current_master_tip);
  	must_pass(git_reference_create_oid(&ref, repo, new_ref, &oid, 0));
  	must_pass(git_reference_lookup(&ref, repo, new_ref));
  
  	must_pass(git_signature_now(&committer, "foo", "foo@bar"));
  
  	/* Write the reflog for the new branch */
  	must_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. */
  	must_fail(git_reflog_write(ref, NULL, committer, NULL));
  
  	git_signature_free(committer);
  
  	close_temp_repo(repo);
  END_TEST
  
  BEGIN_SUITE(refs)
  	ADD_TEST(readtag0);
  	ADD_TEST(readtag1);
  
  	ADD_TEST(readsym0);
  	ADD_TEST(readsym1);
  	ADD_TEST(readsym2);
  	ADD_TEST(readsym3);
  
  	ADD_TEST(readpacked0);
  	ADD_TEST(readpacked1);
  
  	ADD_TEST(create0);
  	ADD_TEST(create1);
  	ADD_TEST(create2);
  	ADD_TEST(create3);
  
  	ADD_TEST(overwrite0);
  	ADD_TEST(overwrite1);
  	ADD_TEST(overwrite2);
  	ADD_TEST(overwrite3);
  
  	ADD_TEST(normalize0);
  	ADD_TEST(normalize1);
  	ADD_TEST(normalize2);
  
  	ADD_TEST(pack0);
  	ADD_TEST(pack1);
  
  	ADD_TEST(rename0);
  	ADD_TEST(rename1);
  	ADD_TEST(rename2);
  	ADD_TEST(rename3);
  	ADD_TEST(rename4);
  	ADD_TEST(rename5);
  	ADD_TEST(rename6);
  	ADD_TEST(rename7);
  	ADD_TEST(rename8);
  
  	ADD_TEST(delete0);
  
  	ADD_TEST(list0);
  	ADD_TEST(list1);
  
  	ADD_TEST(reflog0);
  	ADD_TEST(reflog1);
  END_SUITE
  

Download