rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clar/object/message.c

@@ -0,0 +1,171 @@
+#include "clar_libgit2.h"
+#include "buffer.h"
+#include "message.h"
+
+static void assert_message_prettifying(char *expected_output, char *input, int strip_comments)
+{
+	git_buf prettified_message = GIT_BUF_INIT;
+
+	git_message_prettify(&prettified_message, input, strip_comments);
+	cl_assert_equal_s(expected_output, git_buf_cstr(&prettified_message));
+
+	git_buf_free(&prettified_message);
+}
+
+#define t40 "A quick brown fox jumps over the lazy do"
+#define s40 "                                        "
+#define sss s40 s40 s40 s40 s40 s40 s40 s40 s40 s40 // # 400
+#define ttt t40 t40 t40 t40 t40 t40 t40 t40 t40 t40 // # 400
+
+/* Ported from git.git */
+/* see https://github.com/git/git/blob/master/t/t0030-stripspace.sh */
+void test_object_message__long_lines_without_spaces_should_be_unchanged(void)
+{
+	assert_message_prettifying(ttt "\n", ttt, 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt, 0);
+	assert_message_prettifying(ttt ttt ttt "\n", ttt ttt ttt, 0);
+	assert_message_prettifying(ttt ttt ttt ttt "\n", ttt ttt ttt ttt, 0);
+}
+
+void test_object_message__lines_with_spaces_at_the_beginning_should_be_unchanged(void)
+{
+	assert_message_prettifying(sss ttt "\n", sss ttt, 0);
+	assert_message_prettifying(sss sss ttt "\n", sss sss ttt, 0);
+	assert_message_prettifying(sss sss sss ttt "\n", sss sss sss ttt, 0);
+}
+
+void test_object_message__lines_with_intermediate_spaces_should_be_unchanged(void)
+{
+	assert_message_prettifying(ttt sss ttt "\n", ttt sss ttt, 0);
+	assert_message_prettifying(ttt sss sss ttt "\n", ttt sss sss ttt, 0);
+}
+
+void test_object_message__consecutive_blank_lines_should_be_unified(void)
+{
+	assert_message_prettifying(ttt "\n\n" ttt "\n", ttt "\n\n\n\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt "\n\n" ttt "\n", ttt ttt "\n\n\n\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt ttt "\n\n" ttt "\n", ttt ttt ttt "\n\n\n\n\n" ttt "\n", 0);
+
+	assert_message_prettifying(ttt "\n\n" ttt ttt "\n", ttt "\n\n\n\n\n" ttt ttt "\n", 0);
+	assert_message_prettifying(ttt "\n\n" ttt ttt ttt "\n", ttt "\n\n\n\n\n" ttt ttt ttt "\n", 0);
+
+	assert_message_prettifying(ttt "\n\n" ttt "\n", ttt "\n\t\n \n\n  \t\t\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt "\n\n" ttt "\n", ttt ttt "\n\t\n \n\n  \t\t\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt ttt "\n\n" ttt "\n", ttt ttt ttt "\n\t\n \n\n  \t\t\n" ttt "\n", 0);
+
+	assert_message_prettifying(ttt "\n\n" ttt ttt "\n", ttt "\n\t\n \n\n  \t\t\n" ttt ttt "\n", 0);
+	assert_message_prettifying(ttt "\n\n" ttt ttt ttt "\n", ttt "\n\t\n \n\n  \t\t\n" ttt ttt ttt "\n", 0);
+}
+
+void test_object_message__only_consecutive_blank_lines_should_be_completely_removed(void)
+{
+	assert_message_prettifying("", "\n", 0);
+	assert_message_prettifying("", "\n\n\n", 0);
+	assert_message_prettifying("", sss "\n" sss "\n" sss "\n", 0);
+	assert_message_prettifying("", sss sss "\n" sss "\n\n", 0);
+}
+
+void test_object_message__consecutive_blank_lines_at_the_beginning_should_be_removed(void)
+{
+	assert_message_prettifying(ttt "\n", "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", "\n\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt "\n", "\n\n\n" ttt ttt "\n", 0);
+	assert_message_prettifying(ttt ttt ttt "\n", "\n\n\n" ttt ttt ttt "\n", 0);
+	assert_message_prettifying(ttt ttt ttt ttt "\n", "\n\n\n" ttt ttt ttt ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", sss "\n" sss "\n" sss "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", "\n" sss "\n" sss sss "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", sss sss "\n" sss "\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", sss sss sss "\n\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", "\n" sss sss sss "\n\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n", "\n\n" sss sss sss "\n" ttt "\n", 0);
+}
+
+void test_object_message__consecutive_blank_lines_at_the_end_should_be_removed(void)
+{
+	assert_message_prettifying(ttt "\n", ttt "\n\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n\n\n\n", 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt "\n\n\n\n", 0);
+	assert_message_prettifying(ttt ttt ttt "\n", ttt ttt ttt "\n\n\n\n", 0);
+	assert_message_prettifying(ttt ttt ttt ttt "\n", ttt ttt ttt ttt "\n\n\n\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n" sss "\n" sss "\n" sss "\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n\n" sss "\n" sss sss "\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n" sss sss "\n" sss "\n\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n" sss sss sss "\n\n\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n\n" sss sss sss "\n\n", 0);
+	assert_message_prettifying(ttt "\n", ttt "\n\n\n" sss sss sss "\n\n", 0);
+}
+
+void test_object_message__text_without_newline_at_end_should_end_with_newline(void)
+{
+	assert_message_prettifying(ttt "\n", ttt, 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt, 0);
+	assert_message_prettifying(ttt ttt ttt "\n", ttt ttt ttt, 0);
+	assert_message_prettifying(ttt ttt ttt ttt "\n", ttt ttt ttt ttt, 0);
+}
+
+void test_object_message__text_plus_spaces_without_newline_should_not_show_spaces_and_end_with_newline(void)
+{
+	assert_message_prettifying(ttt "\n", ttt sss, 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt sss, 0);
+	assert_message_prettifying(ttt ttt ttt "\n", ttt ttt ttt sss, 0);
+	assert_message_prettifying(ttt "\n", ttt sss sss, 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt sss sss, 0);
+	assert_message_prettifying(ttt "\n", ttt sss sss sss, 0);
+}
+
+void test_object_message__text_plus_spaces_ending_with_newline_should_be_cleaned_and_newline_must_remain(void){
+	assert_message_prettifying(ttt "\n", ttt sss "\n", 0);
+	assert_message_prettifying(ttt "\n", ttt sss sss "\n", 0);
+	assert_message_prettifying(ttt "\n", ttt sss sss sss "\n", 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt sss "\n", 0);
+	assert_message_prettifying(ttt ttt "\n", ttt ttt sss sss "\n", 0);
+	assert_message_prettifying(ttt ttt ttt "\n", ttt ttt ttt sss "\n", 0);
+}
+
+void test_object_message__spaces_with_newline_at_end_should_be_replaced_with_empty_string(void)
+{
+	assert_message_prettifying("", sss "\n", 0);
+	assert_message_prettifying("", sss sss "\n", 0);
+	assert_message_prettifying("", sss sss sss "\n", 0);
+	assert_message_prettifying("", sss sss sss sss "\n", 0);
+}
+
+void test_object_message__spaces_without_newline_at_end_should_be_replaced_with_empty_string(void)
+{
+	assert_message_prettifying("", "", 0);
+	assert_message_prettifying("", sss sss, 0);
+	assert_message_prettifying("", sss sss sss, 0);
+	assert_message_prettifying("", sss sss sss sss, 0);
+}
+
+void test_object_message__consecutive_text_lines_should_be_unchanged(void)
+{
+	assert_message_prettifying(ttt ttt "\n" ttt "\n", ttt ttt "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n" ttt ttt "\n" ttt "\n", ttt "\n" ttt ttt "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n" ttt "\n" ttt "\n" ttt ttt "\n", ttt "\n" ttt "\n" ttt "\n" ttt ttt "\n", 0);
+	assert_message_prettifying(ttt "\n" ttt "\n\n" ttt ttt "\n" ttt "\n", ttt "\n" ttt "\n\n" ttt ttt "\n" ttt "\n", 0);
+	assert_message_prettifying(ttt ttt "\n\n" ttt "\n" ttt ttt "\n", ttt ttt "\n\n" ttt "\n" ttt ttt "\n", 0);
+	assert_message_prettifying(ttt "\n" ttt ttt "\n\n" ttt "\n", ttt "\n" ttt ttt "\n\n" ttt "\n", 0);
+}
+
+void test_object_message__strip_comments(void)
+{
+	assert_message_prettifying("", "# comment", 1);
+	assert_message_prettifying("", "# comment\n", 1);
+	assert_message_prettifying("", "# comment    \n", 1);
+
+	assert_message_prettifying(ttt "\n", ttt "\n" "# comment\n", 1);
+	assert_message_prettifying(ttt "\n", "# comment\n" ttt "\n", 1);
+	assert_message_prettifying(ttt "\n" ttt "\n", ttt "\n" "# comment\n" ttt "\n", 1);
+}
+
+void test_object_message__keep_comments(void)
+{
+	assert_message_prettifying("# comment\n", "# comment", 0);
+	assert_message_prettifying("# comment\n", "# comment\n", 0);
+	assert_message_prettifying("# comment\n", "# comment    \n", 0);
+
+	assert_message_prettifying(ttt "\n" "# comment\n", ttt "\n" "# comment\n", 0);
+	assert_message_prettifying("# comment\n" ttt "\n", "# comment\n" ttt "\n", 0);
+	assert_message_prettifying(ttt "\n" "# comment\n" ttt "\n", ttt "\n" "# comment\n" ttt "\n", 0);
+}

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/chars.c

@@ -1,19 +1,8 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 
-static int from_hex(unsigned int i)
-{
-	if (i >= '0' && i <= '9')
-		return i - '0';
-	if (i >= 'a' && i <= 'f')
-		return 10 + (i - 'a');
-	if (i >= 'A' && i <= 'F')
-		return 10 + (i - 'A');
-	return -1;
-}
-
 void test_object_raw_chars__find_invalid_chars_in_oid(void)
 {
 	git_oid out;
@@ -28,8 +17,8 @@ void test_object_raw_chars__find_invalid_chars_in_oid(void)
 
 	for (i = 0; i < 256; i++) {
 		in[38] = (char)i;
-		if (from_hex(i) >= 0) {
-			exp[19] = (unsigned char)(from_hex(i) << 4);
+		if (git__fromhex(i) >= 0) {
+			exp[19] = (unsigned char)(git__fromhex(i) << 4);
 			cl_git_pass(git_oid_fromstr(&out, in));
 			cl_assert(memcmp(out.id, exp, sizeof(out.id)) == 0);
 		} else {

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/compare.c

@@ -1,5 +1,5 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 
@@ -87,7 +87,7 @@ void test_object_raw_compare__compare_fmt_oids(void)
 
 	/* Format produced the right result */
 	out[GIT_OID_HEXSZ] = '\0';
-	cl_assert(strcmp(exp, out) == 0);
+	cl_assert_equal_s(exp, out);
 }
 
 void test_object_raw_compare__compare_allocfmt_oids(void)
@@ -100,7 +100,7 @@ void test_object_raw_compare__compare_allocfmt_oids(void)
 
 	out = git_oid_allocfmt(&in);
 	cl_assert(out);
-	cl_assert(strcmp(exp, out) == 0);
+	cl_assert_equal_s(exp, out);
 	git__free(out);
 }
 
@@ -120,5 +120,5 @@ void test_object_raw_compare__compare_pathfmt_oids(void)
 
 	/* Format produced the right result */
 	out[GIT_OID_HEXSZ + 1] = '\0';
-	cl_assert(strcmp(exp2, out) == 0);
+	cl_assert_equal_s(exp2, out);
 }

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/convert.c

@@ -1,5 +1,5 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 
@@ -14,24 +14,24 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion(void)
 	cl_git_pass(git_oid_fromstr(&in, exp));
 
 	/* NULL buffer pointer, returns static empty string */
-	str = git_oid_to_string(NULL, sizeof(out), &in);
+	str = git_oid_tostr(NULL, sizeof(out), &in);
 	cl_assert(str && *str == '\0' && str != out);
 
 	/* zero buffer size, returns static empty string */
-	str = git_oid_to_string(out, 0, &in);
+	str = git_oid_tostr(out, 0, &in);
 	cl_assert(str && *str == '\0' && str != out);
 
 	/* NULL oid pointer, returns static empty string */
-	str = git_oid_to_string(out, sizeof(out), NULL);
+	str = git_oid_tostr(out, sizeof(out), NULL);
 	cl_assert(str && *str == '\0' && str != out);
 
 	/* n == 1, returns out as an empty string */
-	str = git_oid_to_string(out, 1, &in);
+	str = git_oid_tostr(out, 1, &in);
 	cl_assert(str && *str == '\0' && str == out);
 
 	for (i = 1; i < GIT_OID_HEXSZ; i++) {
 		out[i+1] = 'Z';
-		str = git_oid_to_string(out, i+1, &in);
+		str = git_oid_tostr(out, i+1, &in);
 		/* returns out containing c-string */
 		cl_assert(str && str == out);
 		/* must be '\0' terminated */
@@ -43,9 +43,9 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion(void)
 	}
 
 	/* returns out as hex formatted c-string */
-	str = git_oid_to_string(out, sizeof(out), &in);
+	str = git_oid_tostr(out, sizeof(out), &in);
 	cl_assert(str && str == out && *(str+GIT_OID_HEXSZ) == '\0');
-	cl_assert(strcmp(exp, out) == 0);
+	cl_assert_equal_s(exp, out);
 }
 
 void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void)
@@ -64,9 +64,9 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void)
 	big[GIT_OID_HEXSZ+3] = 'Z'; /* ditto */
 
 	/* returns big as hex formatted c-string */
-	str = git_oid_to_string(big, sizeof(big), &in);
+	str = git_oid_tostr(big, sizeof(big), &in);
 	cl_assert(str && str == big && *(str+GIT_OID_HEXSZ) == '\0');
-	cl_assert(strcmp(exp, big) == 0);
+	cl_assert_equal_s(exp, big);
 
 	/* check tail material is untouched */
 	cl_assert(str && str == big && *(str+GIT_OID_HEXSZ+1) == 'X');

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/fromstr.c

@@ -1,5 +1,5 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/hash.c

@@ -1,14 +1,18 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 #include "hash.h"
 
 #include "data.h"
 
-static int hash_object(git_oid *oid, git_rawobj *obj)
+static void hash_object_pass(git_oid *oid, git_rawobj *obj)
 {
-	return git_odb_hash(oid, obj->data, obj->len, obj->type);
+   cl_git_pass(git_odb_hash(oid, obj->data, obj->len, obj->type));
+}
+static void hash_object_fail(git_oid *oid, git_rawobj *obj)
+{
+   cl_git_fail(git_odb_hash(oid, obj->data, obj->len, obj->type));
 }
 
 static char *hello_id = "22596363b3de40b06f981fb85d82312e8c0ed511";
@@ -74,28 +78,28 @@ void test_object_raw_hash__hash_junk_data(void)
 
     /* invalid types: */
     junk_obj.data = some_data;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 
     junk_obj.type = GIT_OBJ__EXT1;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 
     junk_obj.type = GIT_OBJ__EXT2;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 
     junk_obj.type = GIT_OBJ_OFS_DELTA;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 
     junk_obj.type = GIT_OBJ_REF_DELTA;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 
     /* data can be NULL only if len is zero: */
     junk_obj.type = GIT_OBJ_BLOB;
     junk_obj.data = NULL;
-    cl_git_pass(hash_object(&id, &junk_obj));
+    hash_object_pass(&id, &junk_obj);
     cl_assert(git_oid_cmp(&id, &id_zero) == 0);
 
     junk_obj.len = 1;
-    cl_git_fail(hash_object(&id, &junk_obj));
+    hash_object_fail(&id, &junk_obj);
 }
 
 void test_object_raw_hash__hash_commit_object(void)
@@ -103,7 +107,7 @@ void test_object_raw_hash__hash_commit_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, commit_id));
-    cl_git_pass(hash_object(&id2, &commit_obj));
+    hash_object_pass(&id2, &commit_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -112,7 +116,7 @@ void test_object_raw_hash__hash_tree_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, tree_id));
-    cl_git_pass(hash_object(&id2, &tree_obj));
+    hash_object_pass(&id2, &tree_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -121,7 +125,7 @@ void test_object_raw_hash__hash_tag_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, tag_id));
-    cl_git_pass(hash_object(&id2, &tag_obj));
+    hash_object_pass(&id2, &tag_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -130,7 +134,7 @@ void test_object_raw_hash__hash_zero_length_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, zero_id));
-    cl_git_pass(hash_object(&id2, &zero_obj));
+    hash_object_pass(&id2, &zero_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -139,7 +143,7 @@ void test_object_raw_hash__hash_one_byte_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, one_id));
-    cl_git_pass(hash_object(&id2, &one_obj));
+    hash_object_pass(&id2, &one_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -148,7 +152,7 @@ void test_object_raw_hash__hash_two_byte_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, two_id));
-    cl_git_pass(hash_object(&id2, &two_obj));
+    hash_object_pass(&id2, &two_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }
 
@@ -157,6 +161,6 @@ void test_object_raw_hash__hash_multi_byte_object(void)
     git_oid id1, id2;
 
     cl_git_pass(git_oid_fromstr(&id1, some_id));
-    cl_git_pass(hash_object(&id2, &some_obj));
+    hash_object_pass(&id2, &some_obj);
     cl_assert(git_oid_cmp(&id1, &id2) == 0);
 }

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/short.c

@@ -1,5 +1,5 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 #include "hash.h"

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/size.c

@@ -1,5 +1,5 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/object/raw/type2string.c

@@ -1,24 +1,24 @@
 
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 
 #include "odb.h"
 #include "hash.h"
 
 void test_object_raw_type2string__convert_type_to_string(void)
 {
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_BAD), ""));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ__EXT1), ""));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_COMMIT), "commit"));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_TREE), "tree"));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_BLOB), "blob"));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_TAG), "tag"));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ__EXT2), ""));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_OFS_DELTA), "OFS_DELTA"));
-	cl_assert(!strcmp(git_object_type2string(GIT_OBJ_REF_DELTA), "REF_DELTA"));
-
-	cl_assert(!strcmp(git_object_type2string(-2), ""));
-	cl_assert(!strcmp(git_object_type2string(8), ""));
-	cl_assert(!strcmp(git_object_type2string(1234), ""));
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_BAD), "");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ__EXT1), "");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_COMMIT), "commit");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_TREE), "tree");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_BLOB), "blob");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_TAG), "tag");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ__EXT2), "");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_OFS_DELTA), "OFS_DELTA");
+	cl_assert_equal_s(git_object_type2string(GIT_OBJ_REF_DELTA), "REF_DELTA");
+
+	cl_assert_equal_s(git_object_type2string(-2), "");
+	cl_assert_equal_s(git_object_type2string(8), "");
+	cl_assert_equal_s(git_object_type2string(1234), "");
 }
 
 void test_object_raw_type2string__convert_string_to_type(void)