summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/buf/oom.c72
-rw-r--r--tests/core/memmem.c46
-rw-r--r--tests/core/strtol.c105
-rw-r--r--tests/object/commit/parse.c232
-rw-r--r--tests/object/tag/parse.c218
5 files changed, 607 insertions, 66 deletions
diff --git a/tests/buf/oom.c b/tests/buf/oom.c
index 2741a8ddf..726234ef8 100644
--- a/tests/buf/oom.c
+++ b/tests/buf/oom.c
@@ -1,42 +1,47 @@
#include "clar_libgit2.h"
#include "buffer.h"
-/*
- * We want to use some ridiculous size that `malloc` will fail with
- * but that does not otherwise interfere with testing. On Linux, choose
- * a number that is large enough to fail immediately but small enough
- * that valgrind doesn't believe it to erroneously be a negative number.
- * On macOS, choose a number that is large enough to fail immediately
- * without having libc print warnings to stderr.
- */
-#if defined(GIT_ARCH_64) && defined(__linux__)
-# define TOOBIG 0x0fffffffffffffff
-#elif defined(__linux__)
-# define TOOBIG 0x0fffffff
-#elif defined(GIT_ARCH_64)
-# define TOOBIG 0xffffffffffffff00
-#else
-# define TOOBIG 0xffffff00
-#endif
-
-/**
- * If we make a ridiculously large request the first time we
- * actually allocate some space in the git_buf, the realloc()
- * will fail. And because the git_buf_grow() wrapper always
- * sets mark_oom, the code in git_buf_try_grow() will free
- * the internal buffer and set it to git_buf__oom.
- *
- * We initialized the internal buffer to (the static variable)
- * git_buf__initbuf. The purpose of this test is to make sure
- * that we don't try to free the static buffer.
- */
+/* Override default allocators with ones that will fail predictably. */
+
+static git_allocator std_alloc;
+static git_allocator oom_alloc;
+
+static void *oom_malloc(size_t n, const char *file, int line)
+{
+ /* Reject any allocation of more than 100 bytes */
+ return (n > 100) ? NULL : std_alloc.gmalloc(n, file, line);
+}
+
+static void *oom_realloc(void *p, size_t n, const char *file, int line)
+{
+ /* Reject any allocation of more than 100 bytes */
+ return (n > 100) ? NULL : std_alloc.grealloc(p, n, file, line);
+}
+
+void test_buf_oom__initialize(void)
+{
+ git_stdalloc_init_allocator(&std_alloc);
+ git_stdalloc_init_allocator(&oom_alloc);
+
+ oom_alloc.gmalloc = oom_malloc;
+ oom_alloc.grealloc = oom_realloc;
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ALLOCATOR, &oom_alloc));
+}
+
+void test_buf_oom__cleanup(void)
+{
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ALLOCATOR, NULL));
+}
+
void test_buf_oom__grow(void)
{
git_buf buf = GIT_BUF_INIT;
- git_buf_clear(&buf);
+ cl_git_pass(git_buf_grow(&buf, 42));
+ cl_assert(!git_buf_oom(&buf));
- cl_assert(git_buf_grow(&buf, TOOBIG) == -1);
+ cl_assert(git_buf_grow(&buf, 101) == -1);
cl_assert(git_buf_oom(&buf));
git_buf_dispose(&buf);
@@ -46,8 +51,9 @@ void test_buf_oom__grow_by(void)
{
git_buf buf = GIT_BUF_INIT;
- buf.size = SIZE_MAX-10;
+ cl_git_pass(git_buf_grow_by(&buf, 42));
+ cl_assert(!git_buf_oom(&buf));
- cl_assert(git_buf_grow_by(&buf, 50) == -1);
+ cl_assert(git_buf_grow_by(&buf, 101) == -1);
cl_assert(git_buf_oom(&buf));
}
diff --git a/tests/core/memmem.c b/tests/core/memmem.c
new file mode 100644
index 000000000..fd9986d01
--- /dev/null
+++ b/tests/core/memmem.c
@@ -0,0 +1,46 @@
+#include "clar_libgit2.h"
+
+static void assert_found(const char *haystack, const char *needle, size_t expected_pos)
+{
+ cl_assert_equal_p(git__memmem(haystack, haystack ? strlen(haystack) : 0,
+ needle, needle ? strlen(needle) : 0),
+ haystack + expected_pos);
+}
+
+static void assert_absent(const char *haystack, const char *needle)
+{
+ cl_assert_equal_p(git__memmem(haystack, haystack ? strlen(haystack) : 0,
+ needle, needle ? strlen(needle) : 0),
+ NULL);
+}
+
+void test_core_memmem__found(void)
+{
+ assert_found("a", "a", 0);
+ assert_found("ab", "a", 0);
+ assert_found("ba", "a", 1);
+ assert_found("aa", "a", 0);
+ assert_found("aab", "aa", 0);
+ assert_found("baa", "aa", 1);
+ assert_found("dabc", "abc", 1);
+ assert_found("abababc", "abc", 4);
+}
+
+void test_core_memmem__absent(void)
+{
+ assert_absent("a", "b");
+ assert_absent("a", "aa");
+ assert_absent("ba", "ab");
+ assert_absent("ba", "ab");
+ assert_absent("abc", "abcd");
+ assert_absent("abcabcabc", "bcac");
+}
+
+void test_core_memmem__edgecases(void)
+{
+ assert_absent(NULL, NULL);
+ assert_absent("a", NULL);
+ assert_absent(NULL, "a");
+ assert_absent("", "a");
+ assert_absent("a", "");
+}
diff --git a/tests/core/strtol.c b/tests/core/strtol.c
index 0d3b6a5e6..ba79fba51 100644
--- a/tests/core/strtol.c
+++ b/tests/core/strtol.c
@@ -1,45 +1,84 @@
#include "clar_libgit2.h"
-void test_core_strtol__int32(void)
+static void assert_l32_parses(const char *string, int32_t expected, int base)
{
int32_t i;
+ cl_git_pass(git__strntol32(&i, string, strlen(string), NULL, base));
+ cl_assert_equal_i(i, expected);
+}
- cl_git_pass(git__strtol32(&i, "123", NULL, 10));
- cl_assert(i == 123);
- cl_git_pass(git__strtol32(&i, " +123 ", NULL, 10));
- cl_assert(i == 123);
- cl_git_pass(git__strtol32(&i, " +2147483647 ", NULL, 10));
- cl_assert(i == 2147483647);
- cl_git_pass(git__strtol32(&i, " -2147483648 ", NULL, 10));
- cl_assert(i == -2147483648LL);
-
- cl_git_fail(git__strtol32(&i, " 2147483657 ", NULL, 10));
- cl_git_fail(git__strtol32(&i, " -2147483657 ", NULL, 10));
+static void assert_l32_fails(const char *string, int base)
+{
+ int32_t i;
+ cl_git_fail(git__strntol32(&i, string, strlen(string), NULL, base));
}
-void test_core_strtol__int64(void)
+static void assert_l64_parses(const char *string, int64_t expected, int base)
{
int64_t i;
+ cl_git_pass(git__strntol64(&i, string, strlen(string), NULL, base));
+ cl_assert_equal_i(i, expected);
+}
+
+static void assert_l64_fails(const char *string, int base)
+{
+ int64_t i;
+ cl_git_fail(git__strntol64(&i, string, strlen(string), NULL, base));
+}
+
+void test_core_strtol__int32(void)
+{
+ assert_l32_parses("123", 123, 10);
+ assert_l32_parses(" +123 ", 123, 10);
+ assert_l32_parses(" +2147483647 ", 2147483647, 10);
+ assert_l32_parses(" -2147483648 ", -2147483648LL, 10);
+ assert_l32_parses("A", 10, 16);
+ assert_l32_parses("1x1", 1, 10);
- cl_git_pass(git__strtol64(&i, "123", NULL, 10));
- cl_assert(i == 123);
- cl_git_pass(git__strtol64(&i, " +123 ", NULL, 10));
- cl_assert(i == 123);
- cl_git_pass(git__strtol64(&i, " +2147483647 ", NULL, 10));
- cl_assert(i == 2147483647);
- cl_git_pass(git__strtol64(&i, " -2147483648 ", NULL, 10));
- cl_assert(i == -2147483648LL);
- cl_git_pass(git__strtol64(&i, " 2147483657 ", NULL, 10));
- cl_assert(i == 2147483657LL);
- cl_git_pass(git__strtol64(&i, " -2147483657 ", NULL, 10));
- cl_assert(i == -2147483657LL);
- cl_git_pass(git__strtol64(&i, " 9223372036854775807 ", NULL, 10));
- cl_assert(i == INT64_MAX);
- cl_git_pass(git__strtol64(&i, " -9223372036854775808 ", NULL, 10));
- cl_assert(i == INT64_MIN);
- cl_git_pass(git__strtol64(&i, " 0x7fffffffffffffff ", NULL, 16));
- cl_assert(i == INT64_MAX);
- cl_git_pass(git__strtol64(&i, " -0x8000000000000000 ", NULL, 16));
- cl_assert(i == INT64_MIN);
+ assert_l32_fails("", 10);
+ assert_l32_fails("a", 10);
+ assert_l32_fails("x10x", 10);
+ assert_l32_fails(" 2147483657 ", 10);
+ assert_l32_fails(" -2147483657 ", 10);
}
+void test_core_strtol__int64(void)
+{
+ assert_l64_parses("123", 123, 10);
+ assert_l64_parses(" +123 ", 123, 10);
+ assert_l64_parses(" +2147483647 ", 2147483647, 10);
+ assert_l64_parses(" -2147483648 ", -2147483648LL, 10);
+ assert_l64_parses(" 2147483657 ", 2147483657LL, 10);
+ assert_l64_parses(" -2147483657 ", -2147483657LL, 10);
+ assert_l64_parses(" 9223372036854775807 ", INT64_MAX, 10);
+ assert_l64_parses(" -9223372036854775808 ", INT64_MIN, 10);
+ assert_l64_parses(" 0x7fffffffffffffff ", INT64_MAX, 16);
+ assert_l64_parses(" -0x8000000000000000 ", INT64_MIN, 16);
+ assert_l64_parses("1a", 26, 16);
+ assert_l64_parses("1A", 26, 16);
+
+ assert_l64_fails("", 10);
+ assert_l64_fails("a", 10);
+ assert_l64_fails("x10x", 10);
+ assert_l64_fails("0x8000000000000000", 16);
+ assert_l64_fails("-0x8000000000000001", 16);
+}
+
+void test_core_strtol__buffer_length_truncates(void)
+{
+ int32_t i32;
+ int64_t i64;
+
+ cl_git_pass(git__strntol32(&i32, "11", 1, NULL, 10));
+ cl_assert_equal_i(i32, 1);
+
+ cl_git_pass(git__strntol64(&i64, "11", 1, NULL, 10));
+ cl_assert_equal_i(i64, 1);
+}
+
+void test_core_strtol__error_message_cuts_off(void)
+{
+ assert_l32_fails("2147483657foobar", 10);
+ cl_assert(strstr(giterr_last()->message, "2147483657") != NULL);
+ cl_assert(strstr(giterr_last()->message, "foobar") == NULL);
+}
diff --git a/tests/object/commit/parse.c b/tests/object/commit/parse.c
new file mode 100644
index 000000000..a99110f18
--- /dev/null
+++ b/tests/object/commit/parse.c
@@ -0,0 +1,232 @@
+#include "clar_libgit2.h"
+#include "commit.h"
+#include "object.h"
+#include "signature.h"
+
+static void assert_commit_parses(const char *data, size_t datalen,
+ const char *expected_treeid,
+ const char *expected_author,
+ const char *expected_committer,
+ const char *expected_encoding,
+ const char *expected_message,
+ size_t expected_parents)
+{
+ git_commit *commit;
+ if (!datalen)
+ datalen = strlen(data);
+ cl_git_pass(git_object__from_raw((git_object **) &commit, data, datalen, GIT_OBJ_COMMIT));
+
+ if (expected_author) {
+ git_signature *author;
+ cl_git_pass(git_signature_from_buffer(&author, expected_author));
+ cl_assert(git_signature__equal(author, commit->author));
+ cl_assert_equal_s(author->name, commit->author->name);
+ cl_assert_equal_s(author->email, commit->author->email);
+ cl_assert_equal_i(author->when.time, commit->author->when.time);
+ cl_assert_equal_i(author->when.offset, commit->author->when.offset);
+ cl_assert_equal_i(author->when.sign, commit->author->when.sign);
+ git_signature_free(author);
+ }
+
+ if (expected_committer) {
+ git_signature *committer;
+ cl_git_pass(git_signature_from_buffer(&committer, expected_committer));
+ cl_assert_equal_s(committer->name, commit->committer->name);
+ cl_assert_equal_s(committer->email, commit->committer->email);
+ cl_assert_equal_i(committer->when.time, commit->committer->when.time);
+ cl_assert_equal_i(committer->when.offset, commit->committer->when.offset);
+ cl_assert_equal_i(committer->when.sign, commit->committer->when.sign);
+ git_signature_free(committer);
+ }
+
+ if (expected_encoding)
+ cl_assert_equal_s(commit->message_encoding, expected_encoding);
+ else
+ cl_assert_equal_p(commit->message_encoding, NULL);
+
+ if (expected_message)
+ cl_assert_equal_s(commit->raw_message, expected_message);
+ else
+ cl_assert_equal_p(commit->message_encoding, NULL);
+
+ if (expected_treeid) {
+ git_oid tree_oid;
+ cl_git_pass(git_oid_fromstr(&tree_oid, expected_treeid));
+ cl_assert_equal_oid(&tree_oid, &commit->tree_id);
+ }
+
+ cl_assert_equal_i(commit->parent_ids.size, expected_parents);
+
+ git_object__free(&commit->object);
+}
+
+static void assert_commit_fails(const char *data, size_t datalen)
+{
+ git_object *object;
+ if (!datalen)
+ datalen = strlen(data);
+ cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJ_COMMIT));
+}
+
+void test_object_commit_parse__parsing_commit_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "encoding Encoding\n"
+ "\n"
+ "Message";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author <author@example.com>",
+ "Committer <committer@example.com>",
+ "Encoding",
+ "Message", 0);
+}
+
+void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author <author@example.com>",
+ "Committer <committer@example.com>",
+ NULL,
+ "Message", 0);
+}
+
+void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author1 <author@example.com>\n"
+ "author Author2 <author@example.com>\n"
+ "author Author3 <author@example.com>\n"
+ "author Author4 <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author1 <author@example.com>",
+ "Committer <committer@example.com>",
+ NULL,
+ "Message", 0);
+}
+
+void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer1 <committer@example.com>\n"
+ "committer Committer2 <committer@example.com>\n"
+ "committer Committer3 <committer@example.com>\n"
+ "committer Committer4 <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author <author@example.com>",
+ "Committer1 <committer@example.com>",
+ NULL,
+ "Message", 0);
+}
+
+void test_object_commit_parse__parsing_commit_without_message_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author <author@example.com>",
+ "Committer <committer@example.com>",
+ NULL,
+ "", 0);
+}
+
+void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "foo bar\n"
+ "more garbage\n"
+ "\n"
+ "Message";
+ assert_commit_parses(commit, 0,
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "Author <author@example.com>",
+ "Committer <committer@example.com>",
+ NULL,
+ "Message", 0);
+}
+
+void test_object_commit_parse__parsing_commit_with_invalid_tree_fails(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1xxx5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_fails(commit, 0);
+}
+
+void test_object_commit_parse__parsing_commit_without_tree_fails(void)
+{
+ const char *commit =
+ "author Author <author@example.com>\n"
+ "committer Committer <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_fails(commit, 0);
+}
+
+void test_object_commit_parse__parsing_commit_without_author_fails(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "committer Committer <committer@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_fails(commit, 0);
+}
+
+void test_object_commit_parse__parsing_commit_without_committer_fails(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author Author <author@example.com>\n"
+ "\n"
+ "Message";
+ assert_commit_fails(commit, 0);
+}
+
+void test_object_commit_parse__parsing_encoding_will_not_cause_oob_read(void)
+{
+ const char *commit =
+ "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n"
+ "author <>\n"
+ "committer <>\n"
+ "encoding foo\n";
+ /*
+ * As we ignore unknown fields, the cut-off encoding field will be
+ * parsed just fine.
+ */
+ assert_commit_parses(commit, strlen(commit) - strlen("ncoding foo\n"),
+ "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8",
+ "<>",
+ "<>",
+ NULL,
+ "", 0);
+}
diff --git a/tests/object/tag/parse.c b/tests/object/tag/parse.c
new file mode 100644
index 000000000..f701f6b89
--- /dev/null
+++ b/tests/object/tag/parse.c
@@ -0,0 +1,218 @@
+#include "clar_libgit2.h"
+#include "object.h"
+#include "signature.h"
+#include "tag.h"
+
+static void assert_tag_parses(const char *data, size_t datalen,
+ const char *expected_oid,
+ const char *expected_name,
+ const char *expected_tagger,
+ const char *expected_message)
+{
+ git_tag *tag;
+
+ if (!datalen)
+ datalen = strlen(data);
+
+ cl_git_pass(git_object__from_raw((git_object **) &tag, data, datalen, GIT_OBJ_TAG));
+ cl_assert_equal_i(tag->type, GIT_OBJ_TAG);
+
+ if (expected_oid) {
+ git_oid oid;
+ cl_git_pass(git_oid_fromstr(&oid, expected_oid));
+ cl_assert_equal_oid(&oid, &tag->target);
+ }
+
+ if (expected_name)
+ cl_assert_equal_s(expected_name, tag->tag_name);
+ else
+ cl_assert_equal_s(tag->message, NULL);
+
+ if (expected_tagger) {
+ git_signature *tagger;
+ cl_git_pass(git_signature_from_buffer(&tagger, expected_tagger));
+ cl_assert_equal_s(tagger->name, tag->tagger->name);
+ cl_assert_equal_s(tagger->email, tag->tagger->email);
+ cl_assert_equal_i(tagger->when.time, tag->tagger->when.time);
+ cl_assert_equal_i(tagger->when.offset, tag->tagger->when.offset);
+ cl_assert_equal_i(tagger->when.sign, tag->tagger->when.sign);
+ git_signature_free(tagger);
+ } else {
+ cl_assert_equal_s(tag->tagger, NULL);
+ }
+
+ if (expected_message)
+ cl_assert_equal_s(expected_message, tag->message);
+ else
+ cl_assert_equal_s(tag->message, NULL);
+
+ git_object__free(&tag->object);
+}
+
+static void assert_tag_fails(const char *data, size_t datalen)
+{
+ git_object *object;
+ if (!datalen)
+ datalen = strlen(data);
+ cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJ_TAG));
+}
+
+void test_object_tag_parse__valid_tag_parses(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_parses(tag, 0,
+ "a8d447f68076d1520f69649bb52629941be7031f",
+ "tagname",
+ "Taggy Mr. Taggart <taggy@taggart.com>",
+ "Message");
+}
+
+void test_object_tag_parse__missing_tagger_parses(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag tagname\n"
+ "\n"
+ "Message";
+ assert_tag_parses(tag, 0,
+ "a8d447f68076d1520f69649bb52629941be7031f",
+ "tagname",
+ NULL,
+ "Message");
+}
+
+void test_object_tag_parse__missing_message_parses(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n";
+ assert_tag_parses(tag, 0,
+ "a8d447f68076d1520f69649bb52629941be7031f",
+ "tagname",
+ "Taggy Mr. Taggart <taggy@taggart.com>",
+ NULL);
+}
+
+void test_object_tag_parse__unknown_field_parses(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "foo bar\n"
+ "frubble frabble\n"
+ "\n"
+ "Message";
+ assert_tag_parses(tag, 0,
+ "a8d447f68076d1520f69649bb52629941be7031f",
+ "tagname",
+ "Taggy Mr. Taggart <taggy@taggart.com>",
+ "Message");
+}
+
+void test_object_tag_parse__missing_object_fails(void)
+{
+ const char *tag =
+ "type tag\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__malformatted_object_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d15xxxxxxxxxxxxxxxx41be7031f\n"
+ "type tag\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__missing_type_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__invalid_type_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type garbage\n"
+ "tag tagname\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__missing_tagname_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tagger Taggy Mr. Taggart <taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__misformatted_tagger_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag Tag\n"
+ "tagger taggy@taggart.com>\n"
+ "\n"
+ "Message";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__missing_message_fails(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag Tag\n"
+ "tagger taggy@taggart.com>\n";
+ assert_tag_fails(tag, 0);
+}
+
+void test_object_tag_parse__no_oob_read_when_searching_message(void)
+{
+ const char *tag =
+ "object a8d447f68076d1520f69649bb52629941be7031f\n"
+ "type tag\n"
+ "tag \n"
+ "tagger <>\n"
+ " \n\n"
+ "Message";
+ /*
+ * The OOB read previously resulted in an OOM error. We
+ * thus want to make sure that the resulting error is the
+ * expected one.
+ */
+ assert_tag_fails(tag, strlen(tag) - strlen("\n\nMessage"));
+ cl_assert(strstr(giterr_last()->message, "tag contains no message"));
+}
View Lorry Controller Status