t08_tag.c ported.

Also cleaned up some names for things that used to be macros.

tests-clar/index/tests.c

@@ -1,8 +1,8 @@
 #include "clar_libgit2.h"
 #include "index.h"
 
-#define TEST_INDEX_ENTRY_COUNT 109
-#define TEST_INDEX2_ENTRY_COUNT 1437
+static const int index_entry_count = 109;
+static const int index_entry_count_2 = 1437;
 #define TEST_INDEX_PATH cl_fixture("testrepo.git/index")
 #define TEST_INDEX2_PATH cl_fixture("gitgit.index")
 #define TEST_INDEXBIG_PATH cl_fixture("big.index")
@@ -16,7 +16,7 @@ struct test_entry {
    git_time_t mtime;
 };
 
-static struct test_entry TEST_ENTRIES[] = {
+static struct test_entry test_entries[] = {
    {4, "Makefile", 5064, 0x4C3F7F33},
    {62, "tests/Makefile", 2631, 0x4C3F7F33},
    {36, "src/index.c", 10014, 0x4C43368D},
@@ -104,17 +104,17 @@ void test_index_tests__default_test_index(void)
    cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
    cl_assert(index->on_disk);
 
-   cl_assert(git_index_entrycount(index) == TEST_INDEX_ENTRY_COUNT);
+   cl_assert(git_index_entrycount(index) == index_entry_count);
    cl_assert(index->entries.sorted);
 
    entries = (git_index_entry **)index->entries.contents;
 
-   for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
-      git_index_entry *e = entries[TEST_ENTRIES[i].index];
+   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+      git_index_entry *e = entries[test_entries[i].index];
 
-      cl_assert(strcmp(e->path, TEST_ENTRIES[i].path) == 0);
-      cl_assert(e->mtime.seconds == TEST_ENTRIES[i].mtime);
-      cl_assert(e->file_size == TEST_ENTRIES[i].file_size);
+      cl_assert(strcmp(e->path, test_entries[i].path) == 0);
+      cl_assert(e->mtime.seconds == test_entries[i].mtime);
+      cl_assert(e->file_size == test_entries[i].file_size);
    }
 
    git_index_free(index);
@@ -127,7 +127,7 @@ void test_index_tests__gitgit_index(void)
    cl_git_pass(git_index_open(&index, TEST_INDEX2_PATH));
    cl_assert(index->on_disk);
 
-   cl_assert(git_index_entrycount(index) == TEST_INDEX2_ENTRY_COUNT);
+   cl_assert(git_index_entrycount(index) == index_entry_count_2);
    cl_assert(index->entries.sorted);
    cl_assert(index->tree != NULL);
 
@@ -141,9 +141,9 @@ void test_index_tests__find_in_existing(void)
 
    cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
 
-   for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
-      int idx = git_index_find(index, TEST_ENTRIES[i].path);
-      cl_assert(idx == TEST_ENTRIES[i].index);
+   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+      int idx = git_index_find(index, test_entries[i].path);
+      cl_assert(idx == test_entries[i].index);
    }
 
    git_index_free(index);
@@ -156,8 +156,8 @@ void test_index_tests__find_in_empty(void)
 
    cl_git_pass(git_index_open(&index, "fake-index"));
 
-   for (i = 0; i < ARRAY_SIZE(TEST_ENTRIES); ++i) {
-      int idx = git_index_find(index, TEST_ENTRIES[i].path);
+   for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+      int idx = git_index_find(index, test_entries[i].path);
       cl_assert(idx == GIT_ENOTFOUND);
    }
 

tests-clar/tag/read.c

@@ -0,0 +1,128 @@
+#include "clar_libgit2.h"
+
+#include "tag.h"
+
+static const char *tag1_id = "b25fa35b38051e4ae45d4222e795f9df2e43f1d1";
+static const char *tag2_id = "7b4384978d2493e851f9cca7858815fac9b10980";
+static const char *tagged_commit = "e90810b8df3e80c413d903f631643c716887138d";
+static const char *bad_tag_id = "eda9f45a2a98d4c17a09d681d88569fa4ea91755";
+static const char *badly_tagged_commit = "e90810b8df3e80c413d903f631643c716887138d";
+
+static git_repository *g_repo;
+
+
+// Helpers
+static int ensure_tag_pattern_match(git_repository *repo, const char *pattern, const size_t expected_matches)
+{
+   git_strarray tag_list;
+   int error = GIT_SUCCESS;
+
+   if ((error = git_tag_list_match(&tag_list, pattern, repo)) < GIT_SUCCESS)
+      goto exit;
+
+   if (tag_list.count != expected_matches)
+      error = GIT_ERROR;
+
+exit:
+   git_strarray_free(&tag_list);
+   return error;
+}
+
+
+// Fixture setup and teardown
+void test_tag_read__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_tag_read__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+void test_tag_read__parse(void)
+{
+   // read and parse a tag from the repository
+   git_tag *tag1, *tag2;
+   git_commit *commit;
+   git_oid id1, id2, id_commit;
+
+   git_oid_fromstr(&id1, tag1_id);
+   git_oid_fromstr(&id2, tag2_id);
+   git_oid_fromstr(&id_commit, tagged_commit);
+
+   cl_git_pass(git_tag_lookup(&tag1, g_repo, &id1));
+
+   cl_assert(strcmp(git_tag_name(tag1), "test") == 0);
+   cl_assert(git_tag_type(tag1) == GIT_OBJ_TAG);
+
+   cl_git_pass(git_tag_target((git_object **)&tag2, tag1));
+   cl_assert(tag2 != NULL);
+
+   cl_assert(git_oid_cmp(&id2, git_tag_id(tag2)) == 0);
+
+   cl_git_pass(git_tag_target((git_object **)&commit, tag2));
+   cl_assert(commit != NULL);
+
+   cl_assert(git_oid_cmp(&id_commit, git_commit_id(commit)) == 0);
+
+   git_tag_free(tag1);
+   git_tag_free(tag2);
+   git_commit_free(commit);
+}
+
+void test_tag_read__list(void)
+{
+   // list all tag names from the repository
+   git_strarray tag_list;
+
+   cl_git_pass(git_tag_list(&tag_list, g_repo));
+
+   cl_assert(tag_list.count == 3);
+
+   git_strarray_free(&tag_list);
+}
+
+void test_tag_read__list_pattern(void)
+{
+   // list all tag names from the repository matching a specified pattern
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "", 3));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "*", 3));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "t*", 1));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "*b", 2));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "e", 0));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "e90810b", 1));
+   cl_git_pass(ensure_tag_pattern_match(g_repo, "e90810[ab]", 1));
+}
+
+void test_tag_read__parse_without_tagger(void)
+{
+   // read and parse a tag without a tagger field
+   git_repository *bad_tag_repo;
+   git_tag *bad_tag;
+   git_commit *commit;
+   git_oid id, id_commit;
+
+   // TODO: This is a little messy
+   cl_git_pass(git_repository_open(&bad_tag_repo, cl_fixture("bad_tag.git")));
+
+   git_oid_fromstr(&id, bad_tag_id);
+   git_oid_fromstr(&id_commit, badly_tagged_commit);
+
+   cl_git_pass(git_tag_lookup(&bad_tag, bad_tag_repo, &id));
+   cl_assert(bad_tag != NULL);
+
+   cl_assert(strcmp(git_tag_name(bad_tag), "e90810b") == 0);
+   cl_assert(git_oid_cmp(&id, git_tag_id(bad_tag)) == 0);
+   cl_assert(bad_tag->tagger == NULL);
+
+   cl_git_pass(git_tag_target((git_object **)&commit, bad_tag));
+   cl_assert(commit != NULL);
+
+   cl_assert(git_oid_cmp(&id_commit, git_commit_id(commit)) == 0);
+
+   git_tag_free(bad_tag);
+   git_commit_free(commit);
+   git_repository_free(bad_tag_repo);
+}

tests-clar/tag/write.c

@@ -0,0 +1,204 @@
+#include "clar_libgit2.h"
+
+static const char* tagger_name = "Vicent Marti";
+static const char* tagger_email = "vicent@github.com";
+static const char* tagger_message = "This is my tag.\n\nThere are many tags, but this one is mine\n";
+
+static const char *tag2_id = "7b4384978d2493e851f9cca7858815fac9b10980";
+static const char *tagged_commit = "e90810b8df3e80c413d903f631643c716887138d";
+static const char *bad_tag_id = "eda9f45a2a98d4c17a09d681d88569fa4ea91755";
+static const char *badly_tagged_commit = "e90810b8df3e80c413d903f631643c716887138d";
+
+static git_repository *g_repo;
+
+
+// Fixture setup and teardown
+void test_tag_write__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_tag_write__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+
+void test_tag_write__basic(void)
+{
+   // write a tag to the repository and read it again
+	git_tag *tag;
+	git_oid target_id, tag_id;
+	git_signature *tagger;
+	const git_signature *tagger1;
+	git_reference *ref_tag;
+	git_object *target;
+
+	git_oid_fromstr(&target_id, tagged_commit);
+	cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT));
+
+	/* create signature */
+	cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
+
+	cl_git_pass(git_tag_create(
+                              &tag_id, /* out id */
+                              g_repo,
+                              "the-tag",
+                              target,
+                              tagger,
+                              tagger_message,
+                              0));
+
+	git_object_free(target);
+	git_signature_free(tagger);
+
+	cl_git_pass(git_tag_lookup(&tag, g_repo, &tag_id));
+	cl_assert(git_oid_cmp(git_tag_target_oid(tag), &target_id) == 0);
+
+	/* Check attributes were set correctly */
+	tagger1 = git_tag_tagger(tag);
+	cl_assert(tagger1 != NULL);
+	cl_assert(strcmp(tagger1->name, tagger_name) == 0);
+	cl_assert(strcmp(tagger1->email, tagger_email) == 0);
+	cl_assert(tagger1->when.time == 123456789);
+	cl_assert(tagger1->when.offset == 60);
+
+	cl_assert(strcmp(git_tag_message(tag), tagger_message) == 0);
+
+	cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/the-tag"));
+	cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0);
+	cl_git_pass(git_reference_delete(ref_tag));
+#ifndef GIT_WIN32
+	cl_assert((loose_object_mode(REPOSITORY_FOLDER, (git_object *)tag) & 0777) == GIT_OBJECT_FILE_MODE);
+#endif
+
+	git_tag_free(tag);
+}
+
+void test_tag_write__overwrite(void)
+{
+   // Attempt to write a tag bearing the same name than an already existing tag
+	git_oid target_id, tag_id;
+	git_signature *tagger;
+	git_object *target;
+
+	git_oid_fromstr(&target_id, tagged_commit);
+	cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT));
+
+	/* create signature */
+	cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
+
+	cl_git_fail(git_tag_create(
+                              &tag_id, /* out id */
+                              g_repo,
+                              "e90810b",
+                              target,
+                              tagger,
+                              tagger_message,
+                              0));
+
+	git_object_free(target);
+	git_signature_free(tagger);
+
+}
+
+void test_tag_write__replace(void)
+{
+   // Replace an already existing tag
+	git_oid target_id, tag_id, old_tag_id;
+	git_signature *tagger;
+	git_reference *ref_tag;
+	git_object *target;
+
+	git_oid_fromstr(&target_id, tagged_commit);
+	cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT));
+
+	cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b"));
+	git_oid_cpy(&old_tag_id, git_reference_oid(ref_tag));
+	git_reference_free(ref_tag);
+
+	/* create signature */
+	cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
+
+	cl_git_pass(git_tag_create(
+                              &tag_id, /* out id */
+                              g_repo,
+                              "e90810b",
+                              target,
+                              tagger,
+                              tagger_message,
+                              1));
+
+	git_object_free(target);
+	git_signature_free(tagger);
+
+	cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b"));
+	cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0);
+	cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &old_tag_id) != 0);
+
+	git_reference_free(ref_tag);
+}
+
+void test_tag_write__lightweight(void)
+{
+   // write a lightweight tag to the repository and read it again
+	git_oid target_id, object_id;
+	git_reference *ref_tag;
+	git_object *target;
+
+	git_oid_fromstr(&target_id, tagged_commit);
+	cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT));
+
+	cl_git_pass(git_tag_create_lightweight(
+                                          &object_id,
+                                          g_repo,
+                                          "light-tag",
+                                          target,
+                                          0));
+
+	git_object_free(target);
+
+	cl_assert(git_oid_cmp(&object_id, &target_id) == 0);
+
+	cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/light-tag"));
+	cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &target_id) == 0);
+
+	cl_git_pass(git_tag_delete(g_repo, "light-tag"));
+
+	git_reference_free(ref_tag);
+}
+
+void test_tag_write__lightweight_over_existing(void)
+{
+   // Attempt to write a lightweight tag bearing the same name than an already existing tag
+	git_oid target_id, object_id, existing_object_id;
+	git_object *target;
+
+	git_oid_fromstr(&target_id, tagged_commit);
+	cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT));
+
+	cl_git_fail(git_tag_create_lightweight(
+                                          &object_id,
+                                          g_repo,
+                                          "e90810b",
+                                          target,
+                                          0));
+
+	git_oid_fromstr(&existing_object_id, tag2_id);
+	cl_assert(git_oid_cmp(&object_id, &existing_object_id) == 0);
+
+	git_object_free(target);
+}
+
+void test_tag_write__delete(void)
+{
+   // Delete an already existing tag
+	git_reference *ref_tag;
+
+	cl_git_pass(git_tag_delete(g_repo, "e90810b"));
+
+	cl_git_fail(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b"));
+
+	git_reference_free(ref_tag);
+}