diff options
Diffstat (limited to 'tests/t10-refs.c')
| -rw-r--r-- | tests/t10-refs.c | 192 |
1 files changed, 152 insertions, 40 deletions
diff --git a/tests/t10-refs.c b/tests/t10-refs.c index c7bfe4eea..e5e722992 100644 --- a/tests/t10-refs.c +++ b/tests/t10-refs.c @@ -42,8 +42,8 @@ BEGIN_TEST(readtag0, "lookup a loose tag reference") 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(git_reference_type(reference) & GIT_REF_OID); + must_be_true(git_reference_is_packed(reference) == 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)); @@ -56,6 +56,8 @@ BEGIN_TEST(readtag0, "lookup a loose tag reference") git_object_close(object); git_repository_free(repo); + + git_reference_free(reference); END_TEST BEGIN_TEST(readtag1, "lookup a loose tag reference that doesn't exist") @@ -66,6 +68,8 @@ BEGIN_TEST(readtag1, "lookup a loose tag reference that doesn't exist") must_fail(git_reference_lookup(&reference, repo, non_existing_tag_ref_name)); git_repository_free(repo); + + git_reference_free(reference); END_TEST static const char *head_tracker_sym_ref_name = "head-tracker"; @@ -81,12 +85,12 @@ BEGIN_TEST(readsym0, "lookup a symbolic reference") 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(git_reference_type(reference) & GIT_REF_SYMBOLIC); + must_be_true(git_reference_is_packed(reference) == 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_be_true(git_reference_type(resolved_ref) == GIT_REF_OID); must_pass(git_object_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY)); must_be_true(object != NULL); @@ -97,6 +101,9 @@ BEGIN_TEST(readsym0, "lookup a symbolic reference") git_object_close(object); git_repository_free(repo); + + git_reference_free(reference); + git_reference_free(resolved_ref); END_TEST BEGIN_TEST(readsym1, "lookup a nested symbolic reference") @@ -108,12 +115,12 @@ BEGIN_TEST(readsym1, "lookup a nested symbolic reference") 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(git_reference_type(reference) & GIT_REF_SYMBOLIC); + must_be_true(git_reference_is_packed(reference) == 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_be_true(git_reference_type(resolved_ref) == GIT_REF_OID); must_pass(git_object_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY)); must_be_true(object != NULL); @@ -124,6 +131,9 @@ BEGIN_TEST(readsym1, "lookup a nested symbolic reference") git_object_close(object); git_repository_free(repo); + + git_reference_free(reference); + git_reference_free(resolved_ref); END_TEST BEGIN_TEST(readsym2, "lookup the HEAD and resolve the master branch") @@ -133,17 +143,22 @@ BEGIN_TEST(readsym2, "lookup the HEAD and resolve the master branch") 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_resolve(&comp_base_ref, reference)); + git_reference_free(reference); 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))); + git_reference_free(reference); + git_reference_free(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_reference_free(reference); + git_reference_free(resolved_ref); + git_reference_free(comp_base_ref); git_repository_free(repo); END_TEST @@ -160,6 +175,10 @@ BEGIN_TEST(readsym3, "lookup the master branch and then the HEAD") must_pass(git_oid_cmp(git_reference_oid(master_ref), git_reference_oid(resolved_ref))); git_repository_free(repo); + + git_reference_free(reference); + git_reference_free(resolved_ref); + git_reference_free(master_ref); END_TEST static const char *packed_head_name = "refs/heads/packed"; @@ -173,8 +192,8 @@ BEGIN_TEST(readpacked0, "lookup a packed reference") 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(git_reference_type(reference) & GIT_REF_OID); + must_be_true(git_reference_is_packed(reference)); must_be_true(strcmp(reference->name, packed_head_name) == 0); must_pass(git_object_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY)); @@ -183,6 +202,8 @@ BEGIN_TEST(readpacked0, "lookup a packed reference") git_object_close(object); git_repository_free(repo); + + git_reference_free(reference); END_TEST BEGIN_TEST(readpacked1, "assure that a loose reference is looked up before a packed reference") @@ -192,11 +213,13 @@ BEGIN_TEST(readpacked1, "assure that a loose reference is looked up before a pac 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(git_reference_type(reference) & GIT_REF_OID); + must_be_true(git_reference_is_packed(reference) == 0); must_be_true(strcmp(reference->name, packed_test_head_name) == 0); git_repository_free(repo); + + git_reference_free(reference); END_TEST BEGIN_TEST(create0, "create a new symbolic reference") @@ -219,13 +242,13 @@ BEGIN_TEST(create0, "create a new symbolic reference") /* 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(git_reference_type(looked_up_ref) & GIT_REF_SYMBOLIC); + must_be_true(git_reference_is_packed(looked_up_ref) == 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); + must_be_true(git_reference_type(resolved_ref) == 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); @@ -240,6 +263,10 @@ BEGIN_TEST(create0, "create a new symbolic reference") must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0); close_temp_repo(repo2); + + git_reference_free(new_reference); + git_reference_free(looked_up_ref); + git_reference_free(resolved_ref); END_TEST BEGIN_TEST(create1, "create a deep symbolic reference") @@ -261,6 +288,10 @@ BEGIN_TEST(create1, "create a deep symbolic reference") must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0); close_temp_repo(repo); + + git_reference_free(new_reference); + git_reference_free(looked_up_ref); + git_reference_free(resolved_ref); END_TEST BEGIN_TEST(create2, "create a new OID reference") @@ -283,8 +314,8 @@ BEGIN_TEST(create2, "create a new OID reference") /* 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(git_reference_type(looked_up_ref) & GIT_REF_OID); + must_be_true(git_reference_is_packed(looked_up_ref) == 0); must_be_true(strcmp(looked_up_ref->name, new_head) == 0); /* ...and that it points to the current master tip */ @@ -299,6 +330,9 @@ BEGIN_TEST(create2, "create a new OID reference") must_be_true(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0); close_temp_repo(repo2); + + git_reference_free(new_reference); + git_reference_free(looked_up_ref); END_TEST BEGIN_TEST(create3, "Can not create a new OID reference which targets at an unknown id") @@ -349,6 +383,9 @@ BEGIN_TEST(overwrite0, "Overwrite an existing symbolic reference") must_be_true(!strcmp(git_reference_target(ref), ref_master_name)); close_temp_repo(repo); + + git_reference_free(ref); + git_reference_free(branch_ref); END_TEST BEGIN_TEST(overwrite1, "Overwrite an existing object id reference") @@ -359,14 +396,14 @@ BEGIN_TEST(overwrite1, "Overwrite an existing object id reference") 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); + must_be_true(git_reference_type(ref) & 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); /* Ensure we can't overwrite unless we force it */ @@ -378,6 +415,8 @@ BEGIN_TEST(overwrite1, "Overwrite an existing object id reference") must_be_true(!git_oid_cmp(&id, git_reference_oid(ref))); close_temp_repo(repo); + + git_reference_free(ref); END_TEST BEGIN_TEST(overwrite2, "Overwrite an existing object id reference with a symbolic one") @@ -388,7 +427,7 @@ BEGIN_TEST(overwrite2, "Overwrite an existing object id reference with a symboli 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); must_pass(git_reference_create_oid(&ref, repo, ref_name, &id, 0)); @@ -401,6 +440,8 @@ BEGIN_TEST(overwrite2, "Overwrite an existing object id reference with a symboli must_be_true(!strcmp(git_reference_target(ref), ref_master_name)); close_temp_repo(repo); + + git_reference_free(ref); END_TEST BEGIN_TEST(overwrite3, "Overwrite an existing symbolic reference with an object id one") @@ -411,7 +452,7 @@ BEGIN_TEST(overwrite3, "Overwrite an existing symbolic reference with an object 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); /* Create the symbolic ref */ @@ -426,17 +467,18 @@ BEGIN_TEST(overwrite3, "Overwrite an existing symbolic reference with an object must_be_true(!git_oid_cmp(git_reference_oid(ref), &id)); close_temp_repo(repo); + + git_reference_free(ref); 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_futils_mkdir_r(temp_path, GIT_REFS_DIR_MODE)); must_pass(git_reference_packall(repo)); @@ -452,7 +494,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo") /* 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(git_reference_is_packed(reference) == 0); must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0); /* @@ -468,7 +510,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo") /* 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(git_reference_is_packed(reference)); must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0); /* Ensure the known ref has been removed from the loose folder structure */ @@ -476,6 +518,8 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo") must_pass(!git_futils_exists(temp_path)); close_temp_repo(repo); + + git_reference_free(reference); END_TEST BEGIN_TEST(rename0, "rename a loose reference") @@ -494,7 +538,7 @@ BEGIN_TEST(rename0, "rename a loose reference") 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); + must_be_true(git_reference_is_packed(looked_up_ref) == 0); /* Now that the reference is renamed... */ must_pass(git_reference_rename(looked_up_ref, new_name, 0)); @@ -508,14 +552,17 @@ BEGIN_TEST(rename0, "rename a loose reference") 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); + must_be_true(git_reference_is_packed(another_looked_up_ref) == 0); + must_be_true(git_reference_is_packed(looked_up_ref) == 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); + + git_reference_free(looked_up_ref); + git_reference_free(another_looked_up_ref); END_TEST BEGIN_TEST(rename1, "rename a packed reference (should make it loose)") @@ -534,7 +581,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)") 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); + must_be_true(git_reference_is_packed(looked_up_ref) != 0); /* Now that the reference is renamed... */ must_pass(git_reference_rename(looked_up_ref, brand_new_name, 0)); @@ -548,14 +595,17 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)") 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); + must_be_true(git_reference_is_packed(another_looked_up_ref) == 0); + must_be_true(git_reference_is_packed(looked_up_ref) == 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); + + git_reference_free(looked_up_ref); + git_reference_free(another_looked_up_ref); END_TEST BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference which happens to be in both loose and pack state") @@ -574,13 +624,13 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another 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); + must_be_true(git_reference_is_packed(another_looked_up_ref) == 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); + must_be_true(git_reference_is_packed(looked_up_ref) != 0); /* Now that the reference is renamed... */ must_pass(git_reference_rename(looked_up_ref, brand_new_name, 0)); @@ -589,12 +639,15 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another 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); + must_be_true(git_reference_is_packed(another_looked_up_ref) == 0); /* Ensure the other ref still exists on the file system */ must_pass(git_futils_exists(temp_path)); close_temp_repo(repo); + + git_reference_free(looked_up_ref); + git_reference_free(another_looked_up_ref); END_TEST BEGIN_TEST(rename3, "can not rename a reference with the name of an existing reference") @@ -614,6 +667,8 @@ BEGIN_TEST(rename3, "can not rename a reference with the name of an existing ref must_be_true(!strcmp(looked_up_ref->name, packed_head_name)); close_temp_repo(repo); + + git_reference_free(looked_up_ref); END_TEST BEGIN_TEST(rename4, "can not rename a reference with an invalid name") @@ -636,6 +691,8 @@ BEGIN_TEST(rename4, "can not rename a reference with an invalid name") must_be_true(!strcmp(looked_up_ref->name, packed_test_head_name)); close_temp_repo(repo); + + git_reference_free(looked_up_ref); END_TEST BEGIN_TEST(rename5, "can force-rename a packed reference with the name of an existing loose and packed reference") @@ -661,6 +718,8 @@ BEGIN_TEST(rename5, "can force-rename a packed reference with the name of an exi must_fail(git_reference_lookup(&looked_up_ref, repo, packed_head_name)); close_temp_repo(repo); + + git_reference_free(looked_up_ref); END_TEST BEGIN_TEST(rename6, "can force-rename a loose reference with the name of an existing loose reference") @@ -686,6 +745,8 @@ BEGIN_TEST(rename6, "can force-rename a loose reference with the name of an exis must_fail(git_reference_lookup(&looked_up_ref, repo, "refs/heads/br2")); close_temp_repo(repo); + + git_reference_free(looked_up_ref); END_TEST static const char *ref_one_name = "refs/heads/one/branch"; @@ -700,7 +761,7 @@ BEGIN_TEST(rename7, "can not overwrite name of existing reference") 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); @@ -718,6 +779,11 @@ BEGIN_TEST(rename7, "can not overwrite name of existing reference") must_fail(git_reference_lookup(&ref_one_new, repo, ref_one_name_new)); close_temp_repo(repo); + + git_reference_free(ref); + git_reference_free(ref_one); + git_reference_free(ref_one_new); + git_reference_free(ref_two); END_TEST static const char *ref_two_name_new = "refs/heads/two/two"; @@ -730,7 +796,7 @@ BEGIN_TEST(rename8, "can be renamed to a new name prefixed with the old name") 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); @@ -749,6 +815,10 @@ BEGIN_TEST(rename8, "can be renamed to a new name prefixed with the old name") must_fail(git_reference_lookup(&looked_up_ref, repo, ref_two_name)); close_temp_repo(repo); + + git_reference_free(ref); + git_reference_free(ref_two); + git_reference_free(looked_up_ref); END_TEST BEGIN_TEST(rename9, "can move a reference to a upper reference hierarchy") @@ -759,7 +829,7 @@ BEGIN_TEST(rename9, "can move a reference to a upper reference hierarchy") 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); + must_be_true(git_reference_type(ref) & GIT_REF_OID); git_oid_cpy(&id, git_reference_oid(ref)); @@ -795,7 +865,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove 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); + must_be_true(git_reference_is_packed(looked_up_ref) == 0); /* Now that the reference is deleted... */ must_pass(git_reference_delete(looked_up_ref)); @@ -807,6 +877,42 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove must_pass(!git_futils_exists(temp_path)); close_temp_repo(repo); + + git_reference_free(another_looked_up_ref); +END_TEST + +BEGIN_TEST(delete1, "can delete a just packed reference") + git_reference *ref; + git_repository *repo; + git_oid id; + const char *new_ref = "refs/heads/new_ref"; + + git_oid_fromstr(&id, current_master_tip); + + must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER)); + + /* Create and write the new object id reference */ + must_pass(git_reference_create_oid(&ref, repo, new_ref, &id, 0)); + + /* Lookup the reference */ + must_pass(git_reference_lookup(&ref, repo, new_ref)); + + /* Ensure it's a loose reference */ + must_be_true(git_reference_is_packed(ref) == 0); + + /* Pack all existing references */ + must_pass(git_reference_packall(repo)); + + /* Reload the reference from disk */ + must_pass(git_reference_reload(ref)); + + /* Ensure it's a packed reference */ + must_be_true(git_reference_is_packed(ref) == 1); + + /* This should pass */ + must_pass(git_reference_delete(ref)); + + close_temp_repo(repo); END_TEST static int ensure_refname_normalized(int is_oid_ref, const char *input_refname, const char *expected_refname) @@ -1102,6 +1208,9 @@ BEGIN_TEST(reflog0, "write a reflog for a given reference and ensure it can be r git_signature_free(committer); git_reflog_free(reflog); close_temp_repo(repo2); + + git_reference_free(ref); + git_reference_free(lookedup_ref); END_TEST BEGIN_TEST(reflog1, "avoid writing an obviously wrong reflog") @@ -1130,6 +1239,8 @@ BEGIN_TEST(reflog1, "avoid writing an obviously wrong reflog") git_signature_free(committer); close_temp_repo(repo); + + git_reference_free(ref); END_TEST BEGIN_SUITE(refs) @@ -1173,6 +1284,7 @@ BEGIN_SUITE(refs) ADD_TEST(rename9); ADD_TEST(delete0); + ADD_TEST(delete1); ADD_TEST(list0); ADD_TEST(list1); |