libgit-thin/tests/basic.c

   1 #include <time.h>
   2
   3 #include "tests.h"
   4 #include "misc.h"
   5 #include "basic.h"
   6
   7 const char *git_repository_dir1;
   8
   9 /*
  10  * Interface tests
  11  */
  12
  13 START_TEST(git_sha1_conversion_tests)
  14 {
  15         int ret;
  16         char hex[GIT_HEX_LENGTH];
  17         unsigned char sha1[GIT_SHA1_SIZE];
  18         const char orig_hex[] = "190045d53b9a8341e8600d6eb468b6081e903afb";
  19
  20         ret = git_hex_to_sha1(orig_hex, &sha1[0]);
  21         fail_unless(ret == 0, "git_hex_to_sha1() failed: %d\n", ret);
  22
  23         ret = git_sha1_to_hex(sha1, hex);
  24         fail_unless(ret == 0, "git_sha1_to_hex() failed: %d\n", ret);
  25
  26         /*
  27          * XXX: Can you think of a better test?
  28          * How can I hardcode a SHA1?
  29          */
  30         fail_unless(memcmp(orig_hex, hex, GIT_HEX_LENGTH + 1) == 0,
  31                     "%s != %s\n", orig_hex, hex);
  32 }
  33 END_TEST
  34
  35 START_TEST(git_repo_open_test)
  36 {
  37         int err;
  38
  39         err = git_repo_open(git_repository_dir1);
  40         fail_unless(err == 0, "Can't initialize repository [%d]\n", err);
  41 }
  42 END_TEST
  43
  44 START_TEST(git_repo_translate_ref_test)
  45 {
  46         int ret;
  47         size_t com_id_len = 0;
  48         size_t tag_len = 0;
  49         char hex[GIT_HEX_LENGTH + 1], *com_id, *tag;
  50         unsigned char sha1[GIT_SHA1_SIZE];
  51
  52         spec_file_get_checked("TEST_COMMIT1_ID", &com_id, &com_id_len);
  53         spec_file_get_checked("TEST_TAG1_NAME", &tag, &tag_len);
  54
  55         ret = git_repo_open(git_repository_dir1);
  56         fail_unless(ret == 0, "Can't initialize repository [%d]\n", ret);
  57
  58         /*
  59          * HEAD
  60          */
  61
  62         ret = git_repo_translate_ref("HEAD", sha1);
  63         fail_unless(ret == 0, "git_translate_ref() failed: %s\n",
  64                     strerror(errno));
  65
  66         memset(hex, 0, GIT_HEX_LENGTH + 1);
  67         ret = git_sha1_to_hex(sha1, hex);
  68         fail_unless(ret == 0, "git_sha1_to_hex() failed: %s\n",
  69                     strerror(errno));
  70
  71         fail_unless(memcmp(com_id, hex, GIT_HEX_LENGTH + 1) == 0,
  72                     "%s != %s\n", com_id, hex);
  73
  74         /*
  75          * master
  76          */
  77
  78         ret = git_repo_translate_ref("master", sha1);
  79         fail_unless(ret == 0, "git_translate_ref() failed: %s\n",
  80                     strerror(errno));
  81
  82         memset(hex, 0, GIT_HEX_LENGTH + 1);
  83         ret = git_sha1_to_hex(sha1, hex);
  84         fail_unless(ret == 0, "git_sha1_to_hex() failed: %s\n",
  85                     strerror(errno));
  86
  87         fail_unless(memcmp(com_id, hex, GIT_HEX_LENGTH + 1) == 0,
  88                     "%s != %s\n", com_id, hex);
  89
  90         /*
  91          * tag
  92          */
  93
  94         ret = git_repo_translate_ref(tag, sha1);
  95         fail_unless(ret == 0, "git_translate_ref() failed: %s\n",
  96                     strerror(errno));
  97
  98         memset(hex, 0, GIT_HEX_LENGTH + 1);
  99         ret = git_sha1_to_hex(sha1, hex);
 100         fail_unless(ret == 0, "git_sha1_to_hex() failed: %s\n",
 101                     strerror(errno));
 102
 103         fail_unless(memcmp(com_id, hex, GIT_HEX_LENGTH + 1) == 0,
 104                     "%s != %s\n", com_id, hex);
 105
 106         /*
 107          * git_repo_head()
 108          *
 109          * This is tested here because git_repo_head() is just
 110          * a wrapper for git_repo_translate_ref("HEAD", sha1);
 111          */
 112
 113         ret = git_repo_head(sha1);
 114         fail_unless(ret == 0, "git_repo_head() failed: %s\n", strerror(errno));
 115
 116         ret = git_sha1_to_hex(sha1, hex);
 117         fail_unless(ret == 0, "git_sha1_to_hex() failed: %s\n",
 118                     strerror(errno));
 119
 120         fail_unless(memcmp(com_id, hex, GIT_HEX_LENGTH + 1) == 0,
 121                     "%s != %s\n", com_id, hex);
 122
 123         free(tag);
 124         free(com_id);
 125 }
 126 END_TEST
 127
 128 START_TEST(git_revlist_init_test)
 129 {
 130         struct git_revlist_opt *opt;
 131
 132         opt = git_revlist_init();
 133         fail_unless(opt != NULL, "opt is NULL\n");
 134
 135         free(opt);
 136 }
 137 END_TEST
 138
 139 START_TEST(git_revlist_free_test)
 140 {
 141         struct git_revlist_opt *opt;
 142
 143         opt = git_revlist_init();
 144         fail_unless(opt != NULL, "opt is NULL\n");
 145
 146         git_revlist_free(opt);
 147 }
 148 END_TEST
 149
 150 START_TEST(git_commit_init_test)
 151 {
 152         struct git_commit *commit;
 153
 154         commit = git_commit_init();
 155         fail_unless(commit != NULL, "commit is NULL\n");
 156
 157         free(commit);
 158 }
 159 END_TEST
 160
 161 START_TEST(git_commit_free_test)
 162 {
 163         struct git_commit *commit;
 164
 165         commit = git_commit_init();
 166         fail_unless(commit != NULL, "commit is NULL\n");
 167
 168         git_commit_free(commit);
 169 }
 170 END_TEST
 171
 172 /*
 173  * This test assures that git_repo_open(), git_repo_head(),
 174  * git_revlist_include() and git_revlist_next() are working
 175  * and can be used in the setup/teardown functions of other
 176  * test-suites.
 177  */
 178 START_TEST(git_revlist_one_commit_test)
 179 {
 180         int ret;
 181         struct git_commit *commit;
 182         struct git_revlist_opt *opt;
 183         unsigned char sha1[GIT_HEX_LENGTH];
 184
 185         ret = git_repo_open(git_repository_dir1);
 186         fail_unless(ret == 0, "Can't initialize repository [%d]\n", ret);
 187
 188         ret = git_repo_head(sha1);
 189         fail_unless(ret == 0, "git_repo_head() failed: %s\n", strerror(errno));
 190
 191         opt = git_revlist_init();
 192         fail_unless(opt != NULL, "opt is NULL\n");
 193
 194         commit = git_commit_init();
 195         fail_unless(commit != NULL, "commit is NULL\n");
 196
 197         ret = git_revlist_include(opt, sha1);
 198         fail_unless(ret == 0, "git_revlist_include() failed: %s\n",
 199                     strerror(errno));
 200
 201         ret = git_revlist_next(opt, commit);
 202         fail_unless(ret == 1, "No commit to get (ret is %d)\n", ret);
 203
 204         ret = git_revlist_next(opt, commit);
 205         fail_unless(ret == 0, "There should be only one commit [%d]\n", ret);
 206
 207         git_revlist_free(opt);
 208         git_commit_free(commit);
 209 }
 210 END_TEST
 211
 212 /*
 213  * Revision listing tests
 214  */
 215
 216 static struct git_revlist_opt *revl_opt;
 217 static struct git_commit *revl_commit;
 218
 219 static void revl_setup(void)
 220 {
 221         int ret;
 222         unsigned char sha1[GIT_SHA1_SIZE];
 223
 224         ret = git_repo_open(git_repository_dir1);
 225         fail_unless(ret == 0, "Can't initialize repository [%d]\n", ret);
 226
 227         ret = git_repo_head(sha1);
 228         fail_unless(ret == 0, "git_repo_head() failed: %s\n", strerror(errno));
 229
 230         revl_opt = git_revlist_init();
 231         fail_unless(revl_opt != NULL, "revl_opt is NULL\n");
 232
 233         ret = git_revlist_include(revl_opt, sha1);
 234         fail_unless(ret == 0, "git_revlist_include() failed: %s\n",
 235                     strerror(errno));
 236
 237         revl_commit = git_commit_init();
 238         fail_unless(revl_commit != NULL, "revl_commit is NULL\n");
 239
 240         ret = git_revlist_next(revl_opt, revl_commit);
 241         fail_unless(ret != 0, "No commit to get (ret is 0)\n");
 242 }
 243
 244 static void revl_teardown(void)
 245 {
 246         git_revlist_free(revl_opt);
 247         git_commit_free(revl_commit);
 248 }
 249
 250 START_TEST(git_commit_raw_test)
 251 {
 252         size_t len = 0;
 253         char *author;
 254         const char *raw_buf;
 255
 256         spec_file_get_checked("TEST_USER1_AUTHOR", &author, &len);
 257
 258         /*
 259          * XXX: should check the whole buffer
 260          */
 261         raw_buf = git_commit_raw(revl_commit);
 262         fail_unless(raw_buf != NULL, "raw_buf is NULL\n");
 263         fail_unless(strstr(raw_buf, author) != NULL, "raw_buf: %s", raw_buf);
 264
 265         free(author);
 266 }
 267 END_TEST
 268
 269 START_TEST(git_commit_id_test)
 270 {
 271         size_t len = 0;
 272         char *orig_id;
 273         const char *id;
 274
 275         spec_file_get_checked("TEST_COMMIT1_ID", &orig_id, &len);
 276
 277         id = git_commit_id(revl_commit);
 278         fail_unless(!memcmp(id, orig_id, len), "%s != %s\n", id, orig_id);
 279
 280         free(orig_id);
 281 }
 282 END_TEST
 283
 284 START_TEST(git_commit_tree_test)
 285 {
 286         size_t len = 0;
 287         char *orig_tree;
 288         const char *tree;
 289
 290         spec_file_get_checked("TEST_TREE1_ID", &orig_tree, &len);
 291
 292         tree = git_commit_tree(revl_commit);
 293         fail_unless(!memcmp(tree, orig_tree, len), "%s != %s\n",
 294                     tree, orig_tree);
 295
 296         free(orig_tree);
 297 }
 298 END_TEST
 299
 300 START_TEST(git_commit_author_name_test)
 301 {
 302         size_t len = 0;
 303         char *author_name;
 304         const char *ret_author_name;
 305
 306         spec_file_get_checked("TEST_USER1_NAME", &author_name, &len);
 307
 308         ret_author_name = git_commit_author_name(revl_commit);
 309         fail_unless(ret_author_name != NULL, "ret_author_name is NULL\n");
 310         fail_unless(!memcmp(author_name, ret_author_name, len),
 311                     "%s != %s\n", author_name, ret_author_name);
 312
 313         free(author_name);
 314 }
 315 END_TEST
 316
 317 START_TEST(git_commit_author_email_test)
 318 {
 319         size_t len = 0;
 320         char *author_email;
 321         const char *ret_author_email;
 322
 323         spec_file_get_checked("TEST_USER1_EMAIL", &author_email, &len);
 324
 325         ret_author_email = git_commit_author_email(revl_commit);
 326         fail_unless(ret_author_email != NULL, "ret_author_email is NULL\n");
 327         fail_unless(!memcmp(author_email, ret_author_email, len),
 328                     "%s != %s\n", author_email, ret_author_email);
 329
 330         free(author_email);
 331 }
 332 END_TEST
 333
 334 START_TEST(git_commit_author_date_test)
 335 {
 336         int ret, com_tz;
 337         const int hcoded_tz = -200;
 338         time_t com_time;
 339         const time_t hcoded_time = 1165971600;
 340
 341         /* FIXME: hardcoded data */
 342
 343         ret = git_commit_author_date(revl_commit, &com_time, &com_tz);
 344         fail_unless(ret == 0, "can't get author date: %d\n", ret);
 345         fail_unless(com_time == hcoded_time, "%d != %d\n", com_time,
 346                     hcoded_time);
 347         fail_unless(com_tz == hcoded_tz, "%d != %d\n", com_tz, hcoded_tz);
 348 }
 349 END_TEST
 350
 351 START_TEST(git_commit_committer_name_test)
 352 {
 353         size_t len = 0;
 354         char *com_name;
 355         const char *ret_com_name;
 356
 357         spec_file_get_checked("TEST_COMM1_NAME", &com_name, &len);
 358
 359         ret_com_name = git_commit_committer_name(revl_commit);
 360         fail_unless(ret_com_name != NULL, "ret_com_name is NULL\n");
 361         fail_unless(!memcmp(com_name, ret_com_name, len),
 362                     "%s != %s\n", com_name, ret_com_name);
 363
 364         free(com_name);
 365 }
 366 END_TEST
 367
 368 START_TEST(git_commit_committer_email_test)
 369 {
 370         size_t len = 0;
 371         char *com_email;
 372         const char *ret_com_email;
 373
 374         spec_file_get_checked("TEST_COMM1_EMAIL", &com_email, &len);
 375
 376         ret_com_email = git_commit_committer_email(revl_commit);
 377         fail_unless(ret_com_email != NULL, "ret_com_email is NULL\n");
 378         fail_unless(!memcmp(com_email, ret_com_email, len),
 379                     "%s != %s\n", com_email, ret_com_email);
 380
 381         free(com_email);
 382 }
 383 END_TEST
 384
 385 START_TEST(git_commit_committer_date_test)
 386 {
 387         int ret, com_tz;
 388         const int hcoded_tz = -200;
 389         time_t com_time;
 390         const time_t hcoded_time = 1165971600;
 391
 392         /* FIXME: hardcoded data */
 393
 394         ret = git_commit_committer_date(revl_commit, &com_time, &com_tz);
 395         fail_unless(ret == 0, "can't get author date: %d\n", ret);
 396         fail_unless(com_time == hcoded_time, "%d != %d\n", com_time,
 397                     hcoded_time);
 398         fail_unless(com_tz == hcoded_tz, "%d != %d\n", com_tz, hcoded_tz);
 399 }
 400 END_TEST
 401
 402 START_TEST(git_commit_message_test)
 403 {
 404         size_t len = 0;
 405         const char *ret_msg;
 406         char *msg;
 407
 408         spec_file_get_checked("TEST_FILE1_COMMIT", &msg, &len);
 409
 410         // FIXME: We should do a 'len++' to make memcmp() check the
 411         // trailing '\n' (plus '\0'), but we're not checking either
 412         // because spec_file_get() doesn't return the '\n'.
 413         len--;
 414
 415         ret_msg = git_commit_message(revl_commit);
 416         fail_unless(ret_msg != NULL, "ret_msg is NULL\n");
 417         fail_unless(!memcmp(msg, ret_msg, len), "%s != %s\n", msg, ret_msg);
 418
 419         free(msg);
 420 }
 421 END_TEST
 422
 423 /*
 424  * Common errors tests
 425  * (parameters checking mostly)
 426  */
 427
 428 static struct git_commit *err_commit;
 429
 430 static void err_setup(void)
 431 {
 432         err_commit = git_commit_init();
 433         fail_unless(err_commit != NULL, "git_commit_init() failed\n");
 434 }
 435
 436 static void err_teardown(void)
 437 {
 438         git_commit_free(err_commit);
 439 }
 440
 441 static void commit_err_test(const char *(*commit_func)(struct git_commit *commit))
 442 {
 443         const char *ret;
 444
 445         fail_unless(commit_func != NULL, "commit_func() is NULL");
 446
 447         ret = commit_func(NULL);
 448         fail_unless(ret == NULL, "didn't fail\n");
 449         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 450
 451         /* must survive */
 452         ret = commit_func(err_commit);
 453         fail_unless(ret == NULL, "didn't fail\n");
 454         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 455 }
 456
 457 START_TEST(git_hex_to_sha1_err_test)
 458 {
 459         int ret;
 460         const char *hex;
 461         unsigned char sha1[1];
 462
 463         ret = git_hex_to_sha1(NULL, NULL);
 464         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 465         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 466
 467         ret = git_hex_to_sha1(hex, NULL);
 468         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 469         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 470
 471         ret = git_hex_to_sha1(NULL, sha1);
 472         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 473         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 474 }
 475 END_TEST
 476
 477 START_TEST(git_sha1_to_hex_err_test)
 478 {
 479         int ret;
 480         char hex[1];
 481         unsigned char sha1[1];
 482
 483         ret = git_sha1_to_hex(NULL, NULL);
 484         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 485         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 486
 487         ret = git_sha1_to_hex(sha1, NULL);
 488         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 489         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 490
 491         ret = git_sha1_to_hex(NULL, hex);
 492         fail_unless(ret == -1, "git_hex_to_sha1() not failed: %d\n", ret);
 493         fail_unless(errno == EINVAL, "errno is not EINVAL\n", errno);
 494 }
 495 END_TEST
 496
 497 START_TEST(git_repo_open_err_test)
 498 {
 499         int err;
 500
 501         err = git_repo_open(NULL);
 502         fail_unless(err == -1, "didn't fail: %d\n", err);
 503         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 504
 505         err = git_repo_open("akjsndkanskj");
 506         fail_unless(err == -1, "didn't fail: %d\n", err);
 507         fail_unless(errno == ENOENT, "errno doesn't match: %d\n", errno);
 508 }
 509 END_TEST
 510
 511 START_TEST(git_repo_head_err_test)
 512 {
 513         int err;
 514
 515         err = git_repo_head(NULL);
 516         fail_unless(err == -1, "didn't fail: %d\n", err);
 517         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 518 }
 519 END_TEST
 520
 521 START_TEST(git_revlist_next_err_test)
 522 {
 523         int err;
 524         struct git_revlist_opt *opt;
 525
 526         err = git_revlist_next(NULL, NULL);
 527         fail_unless(err == -1, "didn't fail: %d\n", err);
 528         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 529
 530         err = git_revlist_next(opt, NULL);
 531         fail_unless(err == -1, "didn't fail: %d\n", err);
 532         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 533
 534         err = git_revlist_next(NULL, err_commit);
 535         fail_unless(err == -1, "didn't fail: %d\n", err);
 536         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 537 }
 538 END_TEST
 539
 540 START_TEST(git_revlist_include_err_test)
 541 {
 542         int err;
 543         unsigned char sha1[1];
 544         struct git_revlist_opt *opt;
 545
 546         err = git_revlist_include(NULL, NULL);
 547         fail_unless(err == -1, "didn't fail: %d\n", err);
 548         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 549
 550         err = git_revlist_include(opt, NULL);
 551         fail_unless(err == -1, "didn't fail: %d\n", err);
 552         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 553
 554         err = git_revlist_include(NULL, sha1);
 555         fail_unless(err == -1, "didn't fail: %d\n", err);
 556         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 557 }
 558 END_TEST
 559
 560 START_TEST(git_commit_message_err_test)
 561 {
 562         commit_err_test(git_commit_message);
 563 }
 564 END_TEST
 565
 566 START_TEST(git_commit_committer_email_err_test)
 567 {
 568         commit_err_test(git_commit_committer_email);
 569 }
 570 END_TEST
 571
 572 START_TEST(git_commit_committer_name_err_test)
 573 {
 574         commit_err_test(git_commit_committer_name);
 575 }
 576 END_TEST
 577
 578 START_TEST(git_commit_committer_date_err_test)
 579 {
 580         time_t a;
 581         int ret, b;
 582
 583         ret = git_commit_committer_date(NULL, NULL, NULL);
 584         fail_unless(ret == -1, "didn't fail\n");
 585         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 586
 587         /* must survive */
 588         ret = git_commit_committer_date(err_commit, &a, &b);
 589         fail_unless(ret == -1, "didn't fail\n");
 590         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 591 }
 592 END_TEST
 593
 594 START_TEST(git_commit_author_email_err_test)
 595 {
 596         commit_err_test(git_commit_author_email);
 597 }
 598 END_TEST
 599
 600 START_TEST(git_commit_author_date_err_test)
 601 {
 602         time_t a;
 603         int ret, b;
 604
 605         ret = git_commit_author_date(NULL, NULL, NULL);
 606         fail_unless(ret == -1, "didn't fail\n");
 607         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 608
 609         /* must survive */
 610         ret = git_commit_author_date(err_commit, &a, &b);
 611         fail_unless(ret == -1, "didn't fail\n");
 612         fail_unless(errno == EINVAL, "errno doesn't match: %d\n", errno);
 613 }
 614 END_TEST
 615
 616 START_TEST(git_commit_author_name_err_test)
 617 {
 618         commit_err_test(git_commit_author_name);
 619 }
 620 END_TEST
 621
 622 START_TEST(git_commit_id_err_test)
 623 {
 624         commit_err_test(git_commit_id);
 625 }
 626 END_TEST
 627
 628 START_TEST(git_commit_tree_err_test)
 629 {
 630         commit_err_test(git_commit_tree);
 631 }
 632 END_TEST
 633
 634 START_TEST(git_commit_raw_err_test)
 635 {
 636         commit_err_test(git_commit_raw);
 637 }
 638 END_TEST
 639
 640 /*
 641  * Basic test-suite: Performs very simple tests.
 642  *
 643  * The tests that fits in this test-suite are the ones which
 644  * can be performed with a simple GIT repository and usually
 645  * makes weak checks.
 646  *
 647  * This is only useful to first time checking of a function.
 648  */
 649 Suite *test_suite_basic(void)
 650 {
 651         Suite *s;
 652         TCase *tc_interf, *tc_revl, *tc_err;
 653
 654         s = suite_create("Basic");
 655
 656         tc_interf = tcase_create("Interface");
 657         suite_add_tcase(s, tc_interf);
 658         tcase_add_test(tc_interf, git_sha1_conversion_tests);
 659         tcase_add_test(tc_interf, git_repo_open_test);
 660         tcase_add_test(tc_interf, git_repo_translate_ref_test);
 661         tcase_add_test(tc_interf, git_revlist_init_test);
 662         tcase_add_test(tc_interf, git_revlist_free_test);
 663         tcase_add_test(tc_interf, git_commit_init_test);
 664         tcase_add_test(tc_interf, git_commit_free_test);
 665         tcase_add_test(tc_interf, git_revlist_one_commit_test);
 666
 667         /*
 668          * These tests requires revision listing in order
 669          * to be performed.
 670          */
 671         tc_revl = tcase_create("Revision listing");
 672         suite_add_tcase(s, tc_revl);
 673         tcase_add_checked_fixture(tc_revl, revl_setup, revl_teardown);
 674         tcase_add_test(tc_revl, git_commit_raw_test);
 675         tcase_add_test(tc_revl, git_commit_id_test);
 676         tcase_add_test(tc_revl, git_commit_tree_test);
 677         tcase_add_test(tc_revl, git_commit_author_name_test);
 678         tcase_add_test(tc_revl, git_commit_author_email_test);
 679         tcase_add_test(tc_revl, git_commit_author_date_test);
 680         tcase_add_test(tc_revl, git_commit_committer_name_test);
 681         tcase_add_test(tc_revl, git_commit_committer_email_test);
 682         tcase_add_test(tc_revl, git_commit_committer_date_test);
 683         tcase_add_test(tc_revl, git_commit_message_test);
 684
 685         tc_err = tcase_create("Common errors");
 686         suite_add_tcase(s, tc_err);
 687         tcase_add_checked_fixture(tc_err, err_setup, err_teardown);
 688         tcase_add_test(tc_err, git_hex_to_sha1_err_test);
 689         tcase_add_test(tc_err, git_sha1_to_hex_err_test);
 690         tcase_add_test(tc_err, git_repo_open_err_test);
 691         tcase_add_test(tc_err, git_repo_head_err_test);
 692         tcase_add_test(tc_err, git_revlist_next_err_test);
 693         tcase_add_test(tc_err, git_revlist_include_err_test);
 694         tcase_add_test(tc_err, git_commit_message_err_test);
 695         tcase_add_test(tc_err, git_commit_committer_email_err_test);
 696         tcase_add_test(tc_err, git_commit_committer_name_err_test);
 697         tcase_add_test(tc_err, git_commit_committer_date_err_test);
 698         tcase_add_test(tc_err, git_commit_author_email_err_test);
 699         tcase_add_test(tc_err, git_commit_author_name_err_test);
 700         tcase_add_test(tc_err, git_commit_author_date_err_test);
 701         tcase_add_test(tc_err, git_commit_id_err_test);
 702         tcase_add_test(tc_err, git_commit_tree_err_test);
 703         tcase_add_test(tc_err, git_commit_raw_err_test);
 704
 705         return s;
 706 }