+39 -17

bisect.c

··· 28 28 29 29 static struct object_id *current_bad_oid; 30 30 31 31 - static const char *term_bad; 32 32 - static const char *term_good; 31 31 + static char *term_bad; 32 32 + static char *term_good; 33 33 34 34 /* Remember to update object flag allocation in object.h */ 35 35 #define COUNTED (1u<<16) ··· 442 442 best->next = NULL; 443 443 } 444 444 *reaches = weight(best); 445 445 + } else { 446 446 + free_commit_list(*commit_list); 445 447 } 448 448 + *commit_list = best; 449 449 + 446 450 free(weights); 447 447 - *commit_list = best; 448 451 clear_commit_weight(&commit_weight); 449 452 } 450 453 ··· 456 459 strbuf_addstr(&good_prefix, "-"); 457 460 458 461 if (!strcmp(refname, term_bad)) { 462 462 + free(current_bad_oid); 459 463 current_bad_oid = xmalloc(sizeof(*current_bad_oid)); 460 464 oidcpy(current_bad_oid, oid); 461 465 } else if (starts_with(refname, good_prefix.buf)) { ··· 556 560 tried = &list->next; 557 561 } else { 558 562 if (!show_all) { 559 559 - if (!skipped_first || !*skipped_first) 563 563 + if (!skipped_first || !*skipped_first) { 564 564 + free_commit_list(next); 565 565 + free_commit_list(filtered); 560 566 return list; 567 567 + } 561 568 } else if (skipped_first && !*skipped_first) { 562 569 /* This means we know it's not skipped */ 563 570 *skipped_first = -1; ··· 613 620 614 621 static struct commit_list *skip_away(struct commit_list *list, int count) 615 622 { 616 616 - struct commit_list *cur, *previous; 623 623 + struct commit_list *cur, *previous, *result = list; 617 624 int prn, index, i; 618 625 619 626 prn = get_prn(count); ··· 625 632 for (i = 0; cur; cur = cur->next, i++) { 626 633 if (i == index) { 627 634 if (!oideq(&cur->item->object.oid, current_bad_oid)) 628 628 - return cur; 629 629 - if (previous) 630 630 - return previous; 631 631 - return list; 635 635 + result = cur; 636 636 + else if (previous) 637 637 + result = previous; 638 638 + else 639 639 + result = list; 640 640 + break; 632 641 } 633 642 previous = cur; 634 643 } 635 644 636 636 - return list; 645 645 + for (cur = list; cur != result; ) { 646 646 + struct commit_list *next = cur->next; 647 647 + free(cur); 648 648 + cur = next; 649 649 + } 650 650 + 651 651 + return result; 637 652 } 638 653 639 654 static struct commit_list *managed_skipped(struct commit_list *list, ··· 801 816 "between %s and [%s].\n"), 802 817 bad_hex, term_bad, term_good, bad_hex, good_hex); 803 818 } 819 819 + 820 820 + free(good_hex); 804 821 return BISECT_MERGE_BASE_CHECK; 805 822 } 806 823 ··· 848 865 rev + 1, &result) < 0) 849 866 exit(128); 850 867 851 851 - for (; result; result = result->next) { 852 852 - const struct object_id *mb = &result->item->object.oid; 868 868 + for (struct commit_list *l = result; l; l = l->next) { 869 869 + const struct object_id *mb = &l->item->object.oid; 853 870 if (oideq(mb, current_bad_oid)) { 854 871 res = handle_bad_merge_base(); 855 872 break; ··· 985 1002 * We read them and store them to adapt the messages accordingly. 986 1003 * Default is bad/good. 987 1004 */ 988 988 - void read_bisect_terms(const char **read_bad, const char **read_good) 1005 1005 + void read_bisect_terms(char **read_bad, char **read_good) 989 1006 { 990 1007 struct strbuf str = STRBUF_INIT; 991 1008 const char *filename = git_path_bisect_terms(); ··· 993 1010 994 1011 if (!fp) { 995 1012 if (errno == ENOENT) { 996 996 - *read_bad = "bad"; 997 997 - *read_good = "good"; 1013 1013 + free(*read_bad); 1014 1014 + *read_bad = xstrdup("bad"); 1015 1015 + free(*read_good); 1016 1016 + *read_good = xstrdup("good"); 998 1017 return; 999 1018 } else { 1000 1019 die_errno(_("could not read file '%s'"), filename); 1001 1020 } 1002 1021 } else { 1003 1022 strbuf_getline_lf(&str, fp); 1023 1023 + free(*read_bad); 1004 1024 *read_bad = strbuf_detach(&str, NULL); 1005 1025 strbuf_getline_lf(&str, fp); 1026 1026 + free(*read_good); 1006 1027 *read_good = strbuf_detach(&str, NULL); 1007 1028 } 1008 1029 strbuf_release(&str); ··· 1024 1045 { 1025 1046 struct strvec rev_argv = STRVEC_INIT; 1026 1047 struct rev_info revs = REV_INFO_INIT; 1027 1027 - struct commit_list *tried; 1048 1048 + struct commit_list *tried = NULL; 1028 1049 int reaches = 0, all = 0, nr, steps; 1029 1050 enum bisect_error res = BISECT_OK; 1030 1051 struct object_id *bisect_rev; ··· 1091 1112 if (oideq(bisect_rev, current_bad_oid)) { 1092 1113 res = error_if_skipped_commits(tried, current_bad_oid); 1093 1114 if (res) 1094 1094 - return res; 1115 1115 + goto cleanup; 1095 1116 printf("%s is the first %s commit\n", oid_to_hex(bisect_rev), 1096 1117 term_bad); 1097 1118 ··· 1125 1146 1126 1147 res = bisect_checkout(bisect_rev, no_checkout); 1127 1148 cleanup: 1149 1149 + free_commit_list(tried); 1128 1150 release_revisions(&revs); 1129 1151 strvec_clear(&rev_argv); 1130 1152 return res;

+1 -1

bisect.h

··· 75 75 76 76 int estimate_bisect_steps(int all); 77 77 78 78 - void read_bisect_terms(const char **bad, const char **good); 78 78 + void read_bisect_terms(char **bad, char **good); 79 79 80 80 int bisect_clean_state(void); 81 81

+1

blame.c

··· 2931 2931 void cleanup_scoreboard(struct blame_scoreboard *sb) 2932 2932 { 2933 2933 free(sb->lineno); 2934 2934 + free(sb->final_buf); 2934 2935 clear_prio_queue(&sb->commits); 2935 2936 oidset_clear(&sb->ignore_list); 2936 2937

+1 -1

blame.h

··· 116 116 * Used by many functions to obtain contents of the nth line, 117 117 * indexed with scoreboard.lineno[blame_entry.lno]. 118 118 */ 119 119 - const char *final_buf; 119 119 + char *final_buf; 120 120 unsigned long final_buf_size; 121 121 122 122 /* linked list of blames */

+6 -6

builtin/blame.c

··· 1216 1216 output_option &= ~(OUTPUT_COLOR_LINE | OUTPUT_SHOW_AGE_WITH_COLOR); 1217 1217 1218 1218 output(&sb, output_option); 1219 1219 - free((void *)sb.final_buf); 1220 1220 - for (ent = sb.ent; ent; ) { 1221 1221 - struct blame_entry *e = ent->next; 1222 1222 - free(ent); 1223 1223 - ent = e; 1224 1224 - } 1225 1219 1226 1220 if (show_stats) { 1227 1221 printf("num read blob: %d\n", sb.num_read_blob); ··· 1230 1224 } 1231 1225 1232 1226 cleanup: 1227 1227 + for (ent = sb.ent; ent; ) { 1228 1228 + struct blame_entry *e = ent->next; 1229 1229 + free(ent); 1230 1230 + ent = e; 1231 1231 + } 1232 1232 + 1233 1233 free(path); 1234 1234 cleanup_scoreboard(&sb); 1235 1235 release_revisions(&revs);

+22 -11

builtin/branch.c

··· 722 722 static struct ref_sorting *sorting; 723 723 struct string_list sorting_options = STRING_LIST_INIT_DUP; 724 724 struct ref_format format = REF_FORMAT_INIT; 725 725 + int ret; 725 726 726 727 struct option options[] = { 727 728 OPT_GROUP(N_("Generic options")), ··· 851 852 if (list) 852 853 setup_auto_pager("branch", 1); 853 854 854 854 - UNLEAK(sorting_options); 855 855 - 856 855 if (delete) { 857 856 if (!argc) 858 857 die(_("branch name required")); 859 859 - return delete_branches(argc, argv, delete > 1, filter.kind, quiet); 858 858 + ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet); 859 859 + goto out; 860 860 } else if (show_current) { 861 861 print_current_branch_name(); 862 862 - return 0; 862 862 + ret = 0; 863 863 + goto out; 863 864 } else if (list) { 864 865 /* git branch --list also shows HEAD when it is detached */ 865 866 if ((filter.kind & FILTER_REFS_BRANCHES) && filter.detached) ··· 882 883 ref_sorting_release(sorting); 883 884 ref_filter_clear(&filter); 884 885 ref_format_clear(&format); 885 885 - return 0; 886 886 + 887 887 + ret = 0; 888 888 + goto out; 886 889 } else if (edit_description) { 887 890 const char *branch_name; 888 891 struct strbuf branch_ref = STRBUF_INIT; 889 892 struct strbuf buf = STRBUF_INIT; 890 890 - int ret = 1; /* assume failure */ 891 893 892 894 if (!argc) { 893 895 if (filter.detached) ··· 901 903 } 902 904 903 905 strbuf_addf(&branch_ref, "refs/heads/%s", branch_name); 904 904 - if (!refs_ref_exists(get_main_ref_store(the_repository), branch_ref.buf)) 906 906 + if (!refs_ref_exists(get_main_ref_store(the_repository), branch_ref.buf)) { 905 907 error((!argc || branch_checked_out(branch_ref.buf)) 906 908 ? _("no commit on branch '%s' yet") 907 909 : _("no branch named '%s'"), 908 910 branch_name); 909 909 - else if (!edit_branch_description(branch_name)) 911 911 + ret = 1; 912 912 + } else if (!edit_branch_description(branch_name)) { 910 913 ret = 0; /* happy */ 914 914 + } else { 915 915 + ret = 1; 916 916 + } 911 917 912 918 strbuf_release(&branch_ref); 913 919 strbuf_release(&buf); 914 920 915 915 - return ret; 921 921 + goto out; 916 922 } else if (copy || rename) { 917 923 if (!argc) 918 924 die(_("branch name required")); ··· 1000 1006 create_branches_recursively(the_repository, branch_name, 1001 1007 start_name, NULL, force, 1002 1008 reflog, quiet, track, 0); 1003 1003 - return 0; 1009 1009 + ret = 0; 1010 1010 + goto out; 1004 1011 } 1005 1012 create_branch(the_repository, branch_name, start_name, force, 0, 1006 1013 reflog, quiet, track, 0); 1007 1014 } else 1008 1015 usage_with_options(builtin_branch_usage, options); 1009 1016 1010 1010 - return 0; 1017 1017 + ret = 0; 1018 1018 + 1019 1019 + out: 1020 1020 + string_list_clear(&sorting_options, 0); 1021 1021 + return ret; 1011 1022 }

-1

builtin/clone.c

··· 1586 1586 free(dir); 1587 1587 free(path); 1588 1588 free(repo_to_free); 1589 1589 - UNLEAK(repo); 1590 1589 junk_mode = JUNK_LEAVE_ALL; 1591 1590 1592 1591 transport_ls_refs_options_release(&transport_ls_refs_options);

-1

builtin/diff.c

··· 628 628 release_revisions(&rev); 629 629 object_array_clear(&ent); 630 630 symdiff_release(&sdiff); 631 631 - UNLEAK(blob); 632 631 return result; 633 632 }

+7 -6

builtin/help.c

··· 551 551 open_html(page_path.buf); 552 552 } 553 553 554 554 - static const char *check_git_cmd(const char* cmd) 554 554 + static char *check_git_cmd(const char *cmd) 555 555 { 556 556 char *alias; 557 557 558 558 if (is_git_command(cmd)) 559 559 - return cmd; 559 559 + return xstrdup(cmd); 560 560 561 561 alias = alias_lookup(cmd); 562 562 if (alias) { ··· 589 589 die(_("bad alias.%s string: %s"), cmd, 590 590 split_cmdline_strerror(count)); 591 591 free(argv); 592 592 - UNLEAK(alias); 593 592 return alias; 594 593 } 595 594 596 595 if (exclude_guides) 597 596 return help_unknown_cmd(cmd); 598 597 599 599 - return cmd; 598 598 + return xstrdup(cmd); 600 599 } 601 600 602 601 static void no_help_format(const char *opt_mode, enum help_format fmt) ··· 642 641 { 643 642 int nongit; 644 643 enum help_format parsed_help_format; 644 644 + char *command = NULL; 645 645 const char *page; 646 646 647 647 argc = parse_options(argc, argv, prefix, builtin_help_options, ··· 713 713 if (help_format == HELP_FORMAT_NONE) 714 714 help_format = parse_help_format(DEFAULT_HELP_FORMAT); 715 715 716 716 - argv[0] = check_git_cmd(argv[0]); 716 716 + command = check_git_cmd(argv[0]); 717 717 718 718 - page = cmd_to_page(argv[0]); 718 718 + page = cmd_to_page(command); 719 719 switch (help_format) { 720 720 case HELP_FORMAT_NONE: 721 721 case HELP_FORMAT_MAN: ··· 729 729 break; 730 730 } 731 731 732 732 + free(command); 732 733 return 0; 733 734 }

+19 -15

builtin/init-db.c

··· 75 75 const char *prefix, 76 76 struct repository *repo UNUSED) 77 77 { 78 78 - const char *git_dir; 78 78 + char *git_dir; 79 79 const char *real_git_dir = NULL; 80 80 - const char *work_tree; 80 80 + char *real_git_dir_to_free = NULL; 81 81 + char *work_tree = NULL; 81 82 const char *template_dir = NULL; 83 83 + char *template_dir_to_free = NULL; 82 84 unsigned int flags = 0; 83 85 const char *object_format = NULL; 84 86 const char *ref_format = NULL; ··· 106 108 N_("specify the reference format to use")), 107 109 OPT_END() 108 110 }; 111 111 + int ret; 109 112 110 113 argc = parse_options(argc, argv, prefix, init_db_options, init_db_usage, 0); 111 114 ··· 113 116 die(_("options '%s' and '%s' cannot be used together"), "--separate-git-dir", "--bare"); 114 117 115 118 if (real_git_dir && !is_absolute_path(real_git_dir)) 116 116 - real_git_dir = real_pathdup(real_git_dir, 1); 119 119 + real_git_dir = real_git_dir_to_free = real_pathdup(real_git_dir, 1); 117 120 118 118 - if (template_dir && *template_dir && !is_absolute_path(template_dir)) { 119 119 - template_dir = absolute_pathdup(template_dir); 120 120 - UNLEAK(template_dir); 121 121 - } 121 121 + if (template_dir && *template_dir && !is_absolute_path(template_dir)) 122 122 + template_dir = template_dir_to_free = absolute_pathdup(template_dir); 122 123 123 124 if (argc == 1) { 124 125 int mkdir_tried = 0; ··· 192 193 * Set up the default .git directory contents 193 194 */ 194 195 if (!git_dir) 195 195 - git_dir = DEFAULT_GIT_DIR_ENVIRONMENT; 196 196 + git_dir = xstrdup(DEFAULT_GIT_DIR_ENVIRONMENT); 196 197 197 198 /* 198 199 * When --separate-git-dir is used inside a linked worktree, take ··· 213 214 if (chdir(mainwt.buf) < 0) 214 215 die_errno(_("cannot chdir to %s"), mainwt.buf); 215 216 strbuf_release(&mainwt); 217 217 + free(git_dir); 216 218 git_dir = strbuf_detach(&sb, NULL); 217 219 } 218 220 strbuf_release(&sb); ··· 245 247 set_git_work_tree(work_tree); 246 248 } 247 249 248 248 - UNLEAK(real_git_dir); 249 249 - UNLEAK(git_dir); 250 250 - UNLEAK(work_tree); 251 251 - 252 250 flags |= INIT_DB_EXIST_OK; 253 253 - return init_db(git_dir, real_git_dir, template_dir, hash_algo, 254 254 - ref_storage_format, initial_branch, 255 255 - init_shared_repository, flags); 251 251 + ret = init_db(git_dir, real_git_dir, template_dir, hash_algo, 252 252 + ref_storage_format, initial_branch, 253 253 + init_shared_repository, flags); 254 254 + 255 255 + free(template_dir_to_free); 256 256 + free(real_git_dir_to_free); 257 257 + free(work_tree); 258 258 + free(git_dir); 259 259 + return ret; 256 260 }

+39 -22

builtin/sparse-checkout.c

··· 669 669 add_patterns_from_input(pl, argc, argv, use_stdin ? stdin : NULL); 670 670 } 671 671 672 672 - static int modify_pattern_list(int argc, const char **argv, int use_stdin, 672 672 + static int modify_pattern_list(struct strvec *args, int use_stdin, 673 673 enum modify_type m) 674 674 { 675 675 int result; ··· 679 679 switch (m) { 680 680 case ADD: 681 681 if (core_sparse_checkout_cone) 682 682 - add_patterns_cone_mode(argc, argv, pl, use_stdin); 682 682 + add_patterns_cone_mode(args->nr, args->v, pl, use_stdin); 683 683 else 684 684 - add_patterns_literal(argc, argv, pl, use_stdin); 684 684 + add_patterns_literal(args->nr, args->v, pl, use_stdin); 685 685 break; 686 686 687 687 case REPLACE: 688 688 - add_patterns_from_input(pl, argc, argv, 688 688 + add_patterns_from_input(pl, args->nr, args->v, 689 689 use_stdin ? stdin : NULL); 690 690 break; 691 691 } ··· 706 706 return result; 707 707 } 708 708 709 709 - static void sanitize_paths(int argc, const char **argv, 709 709 + static void sanitize_paths(struct strvec *args, 710 710 const char *prefix, int skip_checks) 711 711 { 712 712 int i; 713 713 714 714 - if (!argc) 714 714 + if (!args->nr) 715 715 return; 716 716 717 717 if (prefix && *prefix && core_sparse_checkout_cone) { ··· 721 721 */ 722 722 int prefix_len = strlen(prefix); 723 723 724 724 - for (i = 0; i < argc; i++) 725 725 - argv[i] = prefix_path(prefix, prefix_len, argv[i]); 724 724 + for (i = 0; i < args->nr; i++) { 725 725 + char *prefixed_path = prefix_path(prefix, prefix_len, args->v[i]); 726 726 + strvec_replace(args, i, prefixed_path); 727 727 + free(prefixed_path); 728 728 + } 726 729 } 727 730 728 731 if (skip_checks) ··· 732 735 die(_("please run from the toplevel directory in non-cone mode")); 733 736 734 737 if (core_sparse_checkout_cone) { 735 735 - for (i = 0; i < argc; i++) { 736 736 - if (argv[i][0] == '/') 738 738 + for (i = 0; i < args->nr; i++) { 739 739 + if (args->v[i][0] == '/') 737 740 die(_("specify directories rather than patterns (no leading slash)")); 738 738 - if (argv[i][0] == '!') 741 741 + if (args->v[i][0] == '!') 739 742 die(_("specify directories rather than patterns. If your directory starts with a '!', pass --skip-checks")); 740 740 - if (strpbrk(argv[i], "*?[]")) 743 743 + if (strpbrk(args->v[i], "*?[]")) 741 744 die(_("specify directories rather than patterns. If your directory really has any of '*?[]\\' in it, pass --skip-checks")); 742 745 } 743 746 } 744 747 745 745 - for (i = 0; i < argc; i++) { 748 748 + for (i = 0; i < args->nr; i++) { 746 749 struct cache_entry *ce; 747 750 struct index_state *index = the_repository->index; 748 748 - int pos = index_name_pos(index, argv[i], strlen(argv[i])); 751 751 + int pos = index_name_pos(index, args->v[i], strlen(args->v[i])); 749 752 750 753 if (pos < 0) 751 754 continue; ··· 754 757 continue; 755 758 756 759 if (core_sparse_checkout_cone) 757 757 - die(_("'%s' is not a directory; to treat it as a directory anyway, rerun with --skip-checks"), argv[i]); 760 760 + die(_("'%s' is not a directory; to treat it as a directory anyway, rerun with --skip-checks"), args->v[i]); 758 761 else 759 759 - warning(_("pass a leading slash before paths such as '%s' if you want a single file (see NON-CONE PROBLEMS in the git-sparse-checkout manual)."), argv[i]); 762 762 + warning(_("pass a leading slash before paths such as '%s' if you want a single file (see NON-CONE PROBLEMS in the git-sparse-checkout manual)."), args->v[i]); 760 763 } 761 764 } 762 765 ··· 780 783 N_("read patterns from standard in")), 781 784 OPT_END(), 782 785 }; 786 786 + struct strvec patterns = STRVEC_INIT; 787 787 + int ret; 783 788 784 789 setup_work_tree(); 785 790 if (!core_apply_sparse_checkout) ··· 791 796 builtin_sparse_checkout_add_options, 792 797 builtin_sparse_checkout_add_usage, 0); 793 798 794 794 - sanitize_paths(argc, argv, prefix, add_opts.skip_checks); 799 799 + for (int i = 0; i < argc; i++) 800 800 + strvec_push(&patterns, argv[i]); 801 801 + sanitize_paths(&patterns, prefix, add_opts.skip_checks); 802 802 + 803 803 + ret = modify_pattern_list(&patterns, add_opts.use_stdin, ADD); 795 804 796 796 - return modify_pattern_list(argc, argv, add_opts.use_stdin, ADD); 805 805 + strvec_clear(&patterns); 806 806 + return ret; 797 807 } 798 808 799 809 static char const * const builtin_sparse_checkout_set_usage[] = { ··· 826 836 PARSE_OPT_NONEG), 827 837 OPT_END(), 828 838 }; 839 839 + struct strvec patterns = STRVEC_INIT; 840 840 + int ret; 829 841 830 842 setup_work_tree(); 831 843 repo_read_index(the_repository); ··· 846 858 * top-level directory (much as 'init' would do). 847 859 */ 848 860 if (!core_sparse_checkout_cone && !set_opts.use_stdin && argc == 0) { 849 849 - argv = default_patterns; 850 850 - argc = default_patterns_nr; 861 861 + for (int i = 0; i < default_patterns_nr; i++) 862 862 + strvec_push(&patterns, default_patterns[i]); 851 863 } else { 852 852 - sanitize_paths(argc, argv, prefix, set_opts.skip_checks); 864 864 + for (int i = 0; i < argc; i++) 865 865 + strvec_push(&patterns, argv[i]); 866 866 + sanitize_paths(&patterns, prefix, set_opts.skip_checks); 853 867 } 854 868 855 855 - return modify_pattern_list(argc, argv, set_opts.use_stdin, REPLACE); 869 869 + ret = modify_pattern_list(&patterns, set_opts.use_stdin, REPLACE); 870 870 + 871 871 + strvec_clear(&patterns); 872 872 + return ret; 856 873 } 857 874 858 875 static char const * const builtin_sparse_checkout_reapply_usage[] = {

-1

ci/lib.sh

··· 384 384 ;; 385 385 linux-leaks|linux-reftable-leaks) 386 386 export SANITIZE=leak 387 387 - export GIT_TEST_PASSING_SANITIZE_LEAK=true 388 387 ;; 389 388 linux-asan-ubsan) 390 389 export SANITIZE=address,undefined

-20

git-compat-util.h

··· 1527 1527 int common_exit(const char *file, int line, int code); 1528 1528 #define exit(code) exit(common_exit(__FILE__, __LINE__, (code))) 1529 1529 1530 1530 - /* 1531 1531 - * You can mark a stack variable with UNLEAK(var) to avoid it being 1532 1532 - * reported as a leak by tools like LSAN or valgrind. The argument 1533 1533 - * should generally be the variable itself (not its address and not what 1534 1534 - * it points to). It's safe to use this on pointers which may already 1535 1535 - * have been freed, or on pointers which may still be in use. 1536 1536 - * 1537 1537 - * Use this _only_ for a variable that leaks by going out of scope at 1538 1538 - * program exit (so only from cmd_* functions or their direct helpers). 1539 1539 - * Normal functions, especially those which may be called multiple 1540 1540 - * times, should actually free their memory. This is only meant as 1541 1541 - * an annotation, and does nothing in non-leak-checking builds. 1542 1542 - */ 1543 1543 - #ifdef SUPPRESS_ANNOTATED_LEAKS 1544 1544 - void unleak_memory(const void *ptr, size_t len); 1545 1545 - #define UNLEAK(var) unleak_memory(&(var), sizeof(var)) 1546 1546 - #else 1547 1547 - #define UNLEAK(var) do {} while (0) 1548 1548 - #endif 1549 1549 - 1550 1530 #define z_const 1551 1531 #include <zlib.h> 1552 1532

+63 -59

git.c

··· 362 362 return (*argv) - orig_argv; 363 363 } 364 364 365 365 - static int handle_alias(int *argcp, const char ***argv) 365 365 + static int handle_alias(struct strvec *args) 366 366 { 367 367 int envchanged = 0, ret = 0, saved_errno = errno; 368 368 int count, option_count; ··· 370 370 const char *alias_command; 371 371 char *alias_string; 372 372 373 373 - alias_command = (*argv)[0]; 373 373 + alias_command = args->v[0]; 374 374 alias_string = alias_lookup(alias_command); 375 375 if (alias_string) { 376 376 - if (*argcp > 1 && !strcmp((*argv)[1], "-h")) 376 376 + if (args->nr > 1 && !strcmp(args->v[1], "-h")) 377 377 fprintf_ln(stderr, _("'%s' is aliased to '%s'"), 378 378 alias_command, alias_string); 379 379 if (alias_string[0] == '!') { ··· 390 390 child.wait_after_clean = 1; 391 391 child.trace2_child_class = "shell_alias"; 392 392 strvec_push(&child.args, alias_string + 1); 393 393 - strvec_pushv(&child.args, (*argv) + 1); 393 393 + strvec_pushv(&child.args, args->v + 1); 394 394 395 395 trace2_cmd_alias(alias_command, child.args.v); 396 396 trace2_cmd_name("_run_shell_alias_"); ··· 423 423 trace_argv_printf(new_argv, 424 424 "trace: alias expansion: %s =>", 425 425 alias_command); 426 426 - 427 427 - REALLOC_ARRAY(new_argv, count + *argcp); 428 428 - /* insert after command name */ 429 429 - COPY_ARRAY(new_argv + count, *argv + 1, *argcp); 430 430 - 431 426 trace2_cmd_alias(alias_command, new_argv); 432 427 433 433 - *argv = new_argv; 434 434 - *argcp += count - 1; 428 428 + /* Replace the alias with the new arguments. */ 429 429 + strvec_splice(args, 0, 1, new_argv, count); 430 430 + 431 431 + free(alias_string); 432 432 + free(new_argv); 435 433 436 434 ret = 1; 437 435 } ··· 698 696 } 699 697 700 698 #ifdef STRIP_EXTENSION 701 701 - static void strip_extension(const char **argv) 699 699 + static void strip_extension(struct strvec *args) 702 700 { 703 701 size_t len; 704 702 705 705 - if (strip_suffix(argv[0], STRIP_EXTENSION, &len)) 706 706 - argv[0] = xmemdupz(argv[0], len); 703 703 + if (strip_suffix(args->v[0], STRIP_EXTENSION, &len)) { 704 704 + char *stripped = xmemdupz(args->v[0], len); 705 705 + strvec_replace(args, 0, stripped); 706 706 + free(stripped); 707 707 + } 707 708 } 708 709 #else 709 710 #define strip_extension(cmd) 710 711 #endif 711 712 712 712 - static void handle_builtin(int argc, const char **argv) 713 713 + static void handle_builtin(struct strvec *args) 713 714 { 714 714 - struct strvec args = STRVEC_INIT; 715 715 - const char **argv_copy = NULL; 716 715 const char *cmd; 717 716 struct cmd_struct *builtin; 718 717 719 719 - strip_extension(argv); 720 720 - cmd = argv[0]; 718 718 + strip_extension(args); 719 719 + cmd = args->v[0]; 721 720 722 721 /* Turn "git cmd --help" into "git help --exclude-guides cmd" */ 723 723 - if (argc > 1 && !strcmp(argv[1], "--help")) { 724 724 - int i; 722 722 + if (args->nr > 1 && !strcmp(args->v[1], "--help")) { 723 723 + const char *exclude_guides_arg[] = { "--exclude-guides" }; 725 724 726 726 - argv[1] = argv[0]; 727 727 - argv[0] = cmd = "help"; 728 728 - 729 729 - for (i = 0; i < argc; i++) { 730 730 - strvec_push(&args, argv[i]); 731 731 - if (!i) 732 732 - strvec_push(&args, "--exclude-guides"); 733 733 - } 725 725 + strvec_replace(args, 1, args->v[0]); 726 726 + strvec_replace(args, 0, "help"); 727 727 + cmd = "help"; 728 728 + strvec_splice(args, 2, 0, exclude_guides_arg, 729 729 + ARRAY_SIZE(exclude_guides_arg)); 730 730 + } 734 731 735 735 - argc++; 732 732 + builtin = get_builtin(cmd); 733 733 + if (builtin) { 734 734 + const char **argv_copy = NULL; 735 735 + int ret; 736 736 737 737 /* 738 738 * `run_builtin()` will modify the argv array, so we need to 739 739 * create a shallow copy such that we can free all of its 740 740 * strings. 741 741 */ 742 742 - CALLOC_ARRAY(argv_copy, argc + 1); 743 743 - COPY_ARRAY(argv_copy, args.v, argc); 744 744 - 745 745 - argv = argv_copy; 746 746 - } 742 742 + if (args->nr) 743 743 + DUP_ARRAY(argv_copy, args->v, args->nr + 1); 747 744 748 748 - builtin = get_builtin(cmd); 749 749 - if (builtin) { 750 750 - int ret = run_builtin(builtin, argc, argv, the_repository); 751 751 - strvec_clear(&args); 745 745 + ret = run_builtin(builtin, args->nr, argv_copy, the_repository); 746 746 + strvec_clear(args); 752 747 free(argv_copy); 753 748 exit(ret); 754 749 } 755 755 - 756 756 - strvec_clear(&args); 757 757 - free(argv_copy); 758 750 } 759 751 760 752 static void execv_dashed_external(const char **argv) ··· 800 792 exit(128); 801 793 } 802 794 803 803 - static int run_argv(int *argcp, const char ***argv) 795 795 + static int run_argv(struct strvec *args) 804 796 { 805 797 int done_alias = 0; 806 806 - struct string_list cmd_list = STRING_LIST_INIT_NODUP; 798 798 + struct string_list cmd_list = STRING_LIST_INIT_DUP; 807 799 struct string_list_item *seen; 808 800 809 801 while (1) { ··· 817 809 * process. 818 810 */ 819 811 if (!done_alias) 820 820 - handle_builtin(*argcp, *argv); 821 821 - else if (get_builtin(**argv)) { 812 812 + handle_builtin(args); 813 813 + else if (get_builtin(args->v[0])) { 822 814 struct child_process cmd = CHILD_PROCESS_INIT; 823 815 int i; 824 816 ··· 834 826 commit_pager_choice(); 835 827 836 828 strvec_push(&cmd.args, "git"); 837 837 - for (i = 0; i < *argcp; i++) 838 838 - strvec_push(&cmd.args, (*argv)[i]); 829 829 + for (i = 0; i < args->nr; i++) 830 830 + strvec_push(&cmd.args, args->v[i]); 839 831 840 832 trace_argv_printf(cmd.args.v, "trace: exec:"); 841 833 ··· 850 842 i = run_command(&cmd); 851 843 if (i >= 0 || errno != ENOENT) 852 844 exit(i); 853 853 - die("could not execute builtin %s", **argv); 845 845 + die("could not execute builtin %s", args->v[0]); 854 846 } 855 847 856 848 /* .. then try the external ones */ 857 857 - execv_dashed_external(*argv); 849 849 + execv_dashed_external(args->v); 858 850 859 859 - seen = unsorted_string_list_lookup(&cmd_list, *argv[0]); 851 851 + seen = unsorted_string_list_lookup(&cmd_list, args->v[0]); 860 852 if (seen) { 861 853 int i; 862 854 struct strbuf sb = STRBUF_INIT; ··· 873 865 " not terminate:%s"), cmd_list.items[0].string, sb.buf); 874 866 } 875 867 876 876 - string_list_append(&cmd_list, *argv[0]); 868 868 + string_list_append(&cmd_list, args->v[0]); 877 869 878 870 /* 879 871 * It could be an alias -- this works around the insanity 880 872 * of overriding "git log" with "git show" by having 881 873 * alias.log = show 882 874 */ 883 883 - if (!handle_alias(argcp, argv)) 875 875 + if (!handle_alias(args)) 884 876 break; 885 877 done_alias = 1; 886 878 } ··· 892 884 893 885 int cmd_main(int argc, const char **argv) 894 886 { 887 887 + struct strvec args = STRVEC_INIT; 895 888 const char *cmd; 896 889 int done_help = 0; 897 890 ··· 917 910 * that one cannot handle it. 918 911 */ 919 912 if (skip_prefix(cmd, "git-", &cmd)) { 920 920 - argv[0] = cmd; 921 921 - handle_builtin(argc, argv); 913 913 + strvec_push(&args, cmd); 914 914 + strvec_pushv(&args, argv + 1); 915 915 + handle_builtin(&args); 916 916 + strvec_clear(&args); 922 917 die(_("cannot handle %s as a builtin"), cmd); 923 918 } 924 919 ··· 951 946 */ 952 947 setup_path(); 953 948 949 949 + for (size_t i = 0; i < argc; i++) 950 950 + strvec_push(&args, argv[i]); 951 951 + 954 952 while (1) { 955 955 - int was_alias = run_argv(&argc, &argv); 953 953 + int was_alias = run_argv(&args); 956 954 if (errno != ENOENT) 957 955 break; 958 956 if (was_alias) { 959 957 fprintf(stderr, _("expansion of alias '%s' failed; " 960 958 "'%s' is not a git command\n"), 961 961 - cmd, argv[0]); 959 959 + cmd, args.v[0]); 960 960 + strvec_clear(&args); 962 961 exit(1); 963 962 } 964 963 if (!done_help) { 965 965 - cmd = argv[0] = help_unknown_cmd(cmd); 964 964 + char *assumed = help_unknown_cmd(cmd); 965 965 + strvec_replace(&args, 0, assumed); 966 966 + free(assumed); 967 967 + cmd = args.v[0]; 966 968 done_help = 1; 967 967 - } else 969 969 + } else { 968 970 break; 971 971 + } 969 972 } 970 973 971 974 fprintf(stderr, _("failed to run command '%s': %s\n"), 972 975 cmd, strerror(errno)); 976 976 + strvec_clear(&args); 973 977 974 978 return 1; 975 979 }

+31 -27

help.c

··· 546 546 return 0; 547 547 } 548 548 549 549 - static int autocorrect; 550 550 - static struct cmdnames aliases; 549 549 + struct help_unknown_cmd_config { 550 550 + int autocorrect; 551 551 + struct cmdnames aliases; 552 552 + }; 551 553 552 554 #define AUTOCORRECT_PROMPT (-3) 553 555 #define AUTOCORRECT_NEVER (-2) ··· 555 557 556 558 static int git_unknown_cmd_config(const char *var, const char *value, 557 559 const struct config_context *ctx, 558 558 - void *cb UNUSED) 560 560 + void *cb) 559 561 { 562 562 + struct help_unknown_cmd_config *cfg = cb; 560 563 const char *p; 561 564 562 565 if (!strcmp(var, "help.autocorrect")) { 563 566 if (!value) 564 567 return config_error_nonbool(var); 565 568 if (!strcmp(value, "never")) { 566 566 - autocorrect = AUTOCORRECT_NEVER; 569 569 + cfg->autocorrect = AUTOCORRECT_NEVER; 567 570 } else if (!strcmp(value, "immediate")) { 568 568 - autocorrect = AUTOCORRECT_IMMEDIATELY; 571 571 + cfg->autocorrect = AUTOCORRECT_IMMEDIATELY; 569 572 } else if (!strcmp(value, "prompt")) { 570 570 - autocorrect = AUTOCORRECT_PROMPT; 573 573 + cfg->autocorrect = AUTOCORRECT_PROMPT; 571 574 } else { 572 575 int v = git_config_int(var, value, ctx->kvi); 573 573 - autocorrect = (v < 0) 576 576 + cfg->autocorrect = (v < 0) 574 577 ? AUTOCORRECT_IMMEDIATELY : v; 575 578 } 576 579 } 577 580 /* Also use aliases for command lookup */ 578 581 if (skip_prefix(var, "alias.", &p)) 579 579 - add_cmdname(&aliases, p, strlen(p)); 582 582 + add_cmdname(&cfg->aliases, p, strlen(p)); 580 583 581 584 return 0; 582 585 } ··· 609 612 N_("'%s' appears to be a git command, but we were not\n" 610 613 "able to execute it. Maybe git-%s is broken?"); 611 614 612 612 - const char *help_unknown_cmd(const char *cmd) 615 615 + char *help_unknown_cmd(const char *cmd) 613 616 { 617 617 + struct help_unknown_cmd_config cfg = { 0 }; 614 618 int i, n, best_similarity = 0; 615 615 - struct cmdnames main_cmds, other_cmds; 619 619 + struct cmdnames main_cmds = { 0 }; 620 620 + struct cmdnames other_cmds = { 0 }; 616 621 struct cmdname_help *common_cmds; 617 622 618 618 - memset(&main_cmds, 0, sizeof(main_cmds)); 619 619 - memset(&other_cmds, 0, sizeof(other_cmds)); 620 620 - memset(&aliases, 0, sizeof(aliases)); 621 621 - 622 622 - read_early_config(the_repository, git_unknown_cmd_config, NULL); 623 623 + read_early_config(the_repository, git_unknown_cmd_config, &cfg); 623 624 624 625 /* 625 626 * Disable autocorrection prompt in a non-interactive session 626 627 */ 627 627 - if ((autocorrect == AUTOCORRECT_PROMPT) && (!isatty(0) || !isatty(2))) 628 628 - autocorrect = AUTOCORRECT_NEVER; 628 628 + if ((cfg.autocorrect == AUTOCORRECT_PROMPT) && (!isatty(0) || !isatty(2))) 629 629 + cfg.autocorrect = AUTOCORRECT_NEVER; 629 630 630 630 - if (autocorrect == AUTOCORRECT_NEVER) { 631 631 + if (cfg.autocorrect == AUTOCORRECT_NEVER) { 631 632 fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd); 632 633 exit(1); 633 634 } 634 635 635 636 load_command_list("git-", &main_cmds, &other_cmds); 636 637 637 637 - add_cmd_list(&main_cmds, &aliases); 638 638 + add_cmd_list(&main_cmds, &cfg.aliases); 638 639 add_cmd_list(&main_cmds, &other_cmds); 639 640 QSORT(main_cmds.names, main_cmds.cnt, cmdname_compare); 640 641 uniq(&main_cmds); ··· 693 694 n++) 694 695 ; /* still counting */ 695 696 } 696 696 - if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) { 697 697 - const char *assumed = main_cmds.names[0]->name; 698 698 - main_cmds.names[0] = NULL; 699 699 - cmdnames_release(&main_cmds); 697 697 + if (cfg.autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) { 698 698 + char *assumed = xstrdup(main_cmds.names[0]->name); 699 699 + 700 700 fprintf_ln(stderr, 701 701 _("WARNING: You called a Git command named '%s', " 702 702 "which does not exist."), 703 703 cmd); 704 704 - if (autocorrect == AUTOCORRECT_IMMEDIATELY) 704 704 + if (cfg.autocorrect == AUTOCORRECT_IMMEDIATELY) 705 705 fprintf_ln(stderr, 706 706 _("Continuing under the assumption that " 707 707 "you meant '%s'."), 708 708 assumed); 709 709 - else if (autocorrect == AUTOCORRECT_PROMPT) { 709 709 + else if (cfg.autocorrect == AUTOCORRECT_PROMPT) { 710 710 char *answer; 711 711 struct strbuf msg = STRBUF_INIT; 712 712 strbuf_addf(&msg, _("Run '%s' instead [y/N]? "), assumed); ··· 719 719 fprintf_ln(stderr, 720 720 _("Continuing in %0.1f seconds, " 721 721 "assuming that you meant '%s'."), 722 722 - (float)autocorrect/10.0, assumed); 723 723 - sleep_millisec(autocorrect * 100); 722 722 + (float)cfg.autocorrect/10.0, assumed); 723 723 + sleep_millisec(cfg.autocorrect * 100); 724 724 } 725 725 + 726 726 + cmdnames_release(&cfg.aliases); 727 727 + cmdnames_release(&main_cmds); 728 728 + cmdnames_release(&other_cmds); 725 729 return assumed; 726 730 } 727 731

+1 -1

help.h

··· 32 32 void list_cmds_by_category(struct string_list *list, 33 33 const char *category); 34 34 void list_cmds_by_config(struct string_list *list); 35 35 - const char *help_unknown_cmd(const char *cmd); 35 35 + char *help_unknown_cmd(const char *cmd); 36 36 void load_command_list(const char *prefix, 37 37 struct cmdnames *main_cmds, 38 38 struct cmdnames *other_cmds);

+1

line-log.c

··· 1237 1237 * don't follow any other path in history 1238 1238 */ 1239 1239 add_line_range(rev, parents[i], cand[i]); 1240 1240 + free_commit_list(commit->parents); 1240 1241 commit_list_append(parents[i], &commit->parents); 1241 1242 1242 1243 ret = 0;

+2 -2

revision.c

··· 51 51 52 52 volatile show_early_output_fn_t show_early_output; 53 53 54 54 - static const char *term_bad; 55 55 - static const char *term_good; 54 54 + static char *term_bad; 55 55 + static char *term_good; 56 56 57 57 implement_shared_commit_slab(revision_sources, char *); 58 58

+5 -1

split-index.c

··· 97 97 mem_pool_combine(istate->ce_mem_pool, istate->split_index->base->ce_mem_pool); 98 98 } 99 99 100 100 - ALLOC_ARRAY(si->base, 1); 100 100 + if (si->base) 101 101 + release_index(si->base); 102 102 + else 103 103 + ALLOC_ARRAY(si->base, 1); 104 104 + 101 105 index_state_init(si->base, istate->repo); 102 106 si->base->version = istate->version; 103 107 /* zero timestamp disables racy test in ce_write_index() */

+19

strvec.c

··· 56 56 strvec_push(array, *items); 57 57 } 58 58 59 59 + void strvec_splice(struct strvec *array, size_t idx, size_t len, 60 60 + const char **replacement, size_t replacement_len) 61 61 + { 62 62 + if (idx + len > array->nr) 63 63 + BUG("range outside of array boundary"); 64 64 + if (replacement_len > len) 65 65 + ALLOC_GROW(array->v, array->nr + (replacement_len - len) + 1, 66 66 + array->alloc); 67 67 + for (size_t i = 0; i < len; i++) 68 68 + free((char *)array->v[idx + i]); 69 69 + if (replacement_len != len) { 70 70 + memmove(array->v + idx + replacement_len, array->v + idx + len, 71 71 + (array->nr - idx - len + 1) * sizeof(char *)); 72 72 + array->nr += (replacement_len - len); 73 73 + } 74 74 + for (size_t i = 0; i < replacement_len; i++) 75 75 + array->v[idx + i] = xstrdup(replacement[i]); 76 76 + } 77 77 + 59 78 const char *strvec_replace(struct strvec *array, size_t idx, const char *replacement) 60 79 { 61 80 char *to_free;

+9

strvec.h

··· 67 67 /* Push a null-terminated array of strings onto the end of the array. */ 68 68 void strvec_pushv(struct strvec *, const char **); 69 69 70 70 + /* 71 71 + * Replace `len` values starting at `idx` with the provided replacement 72 72 + * strings. If `len` is zero this is effectively an insert at the given `idx`. 73 73 + * If `replacement_len` is zero this is effectively a delete of `len` items 74 74 + * starting at `idx`. 75 75 + */ 76 76 + void strvec_splice(struct strvec *array, size_t idx, size_t len, 77 77 + const char **replacement, size_t replacement_len); 78 78 + 70 79 /** 71 80 * Replace the value at the given index with a new value. The index must be 72 81 * valid. Returns a pointer to the inserted value.

-21

t/README

··· 368 368 GIT_TEST_SPLIT_INDEX=<boolean> forces split-index mode on the whole 369 369 test suite. Accept any boolean values that are accepted by git-config. 370 370 371 371 - GIT_TEST_PASSING_SANITIZE_LEAK=true skips those tests that haven't 372 372 - declared themselves as leak-free by setting 373 373 - "TEST_PASSES_SANITIZE_LEAK=true" before sourcing "test-lib.sh". This 374 374 - test mode is used by the "linux-leaks" CI target. 375 375 - 376 376 - GIT_TEST_PASSING_SANITIZE_LEAK=check checks that our 377 377 - "TEST_PASSES_SANITIZE_LEAK=true" markings are current. Rather than 378 378 - skipping those tests that haven't set "TEST_PASSES_SANITIZE_LEAK=true" 379 379 - before sourcing "test-lib.sh" this mode runs them with 380 380 - "--invert-exit-code". This is used to check that there's a one-to-one 381 381 - mapping between "TEST_PASSES_SANITIZE_LEAK=true" and those tests that 382 382 - pass under "SANITIZE=leak". This is especially useful when testing a 383 383 - series that fixes various memory leaks with "git rebase -x". 384 384 - 385 385 - GIT_TEST_PASSING_SANITIZE_LEAK=check when combined with "--immediate" 386 386 - will run to completion faster, and result in the same failing 387 387 - tests. 388 388 - 389 389 - GIT_TEST_PASSING_SANITIZE_LEAK=check-failing behaves the same as "check", 390 390 - but skips all tests which are already marked as leak-free. 391 391 - 392 371 GIT_TEST_PROTOCOL_VERSION=<n>, when set, makes 'protocol.version' 393 372 default to n. 394 373

+1 -2

t/helper/test-read-graph.c

··· 97 97 } 98 98 99 99 done: 100 100 - UNLEAK(graph); 101 101 - 100 100 + free_commit_graph(graph); 102 101 return ret; 103 102 }

-4

t/lib-git-svn.sh

··· 1 1 - if test -z "$TEST_FAILS_SANITIZE_LEAK" 2 2 - then 3 3 - TEST_PASSES_SANITIZE_LEAK=true 4 4 - fi 5 1 . ./test-lib.sh 6 2 7 3 if test -n "$NO_SVN_TESTS"

-1

t/t0001-init.sh

··· 2 2 3 3 test_description='git init' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 check_config () {

-1

t/t0002-gitfile.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 objpath() {

-1

t/t0003-attributes.sh

··· 2 2 3 3 test_description=gitattributes 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 TEST_CREATE_REPO_NO_TEMPLATE=1 7 6 . ./test-lib.sh 8 7

-1

t/t0004-unwritable.sh

··· 2 2 3 3 test_description='detect unwritable repository and fail correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t0005-signals.sh

··· 2 2 3 3 test_description='signals work as we expect' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >expect <<EOF

-1

t/t0006-date.sh

··· 2 2 3 3 test_description='test date parsing and printing' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # arbitrary reference time: 2009-08-30 19:20:00

-1

t/t0007-git-var.sh

··· 2 2 3 3 test_description='basic sanity checks for git var' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 sane_unset_all_editors () {

-1

t/t0008-ignores.sh

··· 2 2 3 3 test_description=check-ignore 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 TEST_CREATE_REPO_NO_TEMPLATE=1 7 6 . ./test-lib.sh 8 7

-1

t/t0010-racy-git.sh

··· 2 2 3 3 test_description='racy GIT' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # This test can give false success if your machine is sufficiently

-1

t/t0012-help.sh

··· 2 2 3 3 test_description='help' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 configure_help () {

-1

t/t0013-sha1dc.sh

··· 2 2 3 3 test_description='test sha1 collision detection' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 TEST_DATA="$TEST_DIRECTORY/t0013" 8 7

-1

t/t0017-env-helper.sh

··· 2 2 3 3 test_description='test test-tool env-helper' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7

-1

t/t0018-advice.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=trunk 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'advice should be printed when config variable is unset' '

-1

t/t0019-json-writer.sh

··· 2 2 3 3 test_description='test json-writer JSON generation' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'unit test of json-writer routines' '

-1

t/t0020-crlf.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 has_cr() {

-1

t/t0021-conversion.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-terminal.sh 11 10

-1

t/t0022-crlf-rename.sh

··· 2 2 3 3 test_description='ignore CR in CRLF sequence while computing similiarity' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t0023-crlf-am.sh

··· 2 2 3 3 test_description='Test am with auto.crlf' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >patchfile <<\EOF

-1

t/t0024-crlf-archive.sh

··· 2 2 3 3 test_description='respect crlf in git archive' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t0025-crlf-renormalize.sh

··· 2 2 3 3 test_description='CRLF renormalization' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t0026-eol-config.sh

··· 2 2 3 3 test_description='CRLF conversion' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 has_cr() {

-1

t/t0027-auto-crlf.sh

··· 2 2 3 3 test_description='CRLF conversion all combinations' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 compare_files () {

-1

t/t0028-working-tree-encoding.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 TEST_CREATE_REPO_NO_TEMPLATE=1 10 9 . ./test-lib.sh 11 10 . "$TEST_DIRECTORY/lib-encoding.sh"

-1

t/t0029-core-unsetenvvars.sh

··· 2 2 3 3 test_description='test the Windows-only core.unsetenvvars setting' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if ! test_have_prereq MINGW

-1

t/t0030-stripspace.sh

··· 5 5 6 6 test_description='git stripspace' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 t40='A quick brown fox jumps over the lazy do'

-1

t/t0033-safe-directory.sh

··· 2 2 3 3 test_description='verify safe.directory checks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 GIT_TEST_ASSUME_DIFFERENT_OWNER=1

-1

t/t0035-safe-bare-repository.sh

··· 2 2 3 3 test_description='verify safe.bareRepository checks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 pwd="$(pwd)"

-1

t/t0040-parse-options.sh

··· 5 5 6 6 test_description='our own option parser' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 cat >expect <<\EOF

-1

t/t0041-usage.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup ' '

-1

t/t0050-filesystem.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 auml=$(printf '\303\244')

-1

t/t0052-simple-ipc.sh

··· 2 2 3 3 test_description='simple command server' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test-tool simple-ipc SUPPORTS_SIMPLE_IPC || {

-1

t/t0055-beyond-symlinks.sh

··· 2 2 3 3 test_description='update-index and add refuse to add beyond symlinks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success SYMLINKS setup '

-1

t/t0056-git-C.sh

··· 2 2 3 3 test_description='"-C <path>" option and its effects on other path-related options' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success '"git -C <path>" runs git from the directory <path>' '

-1

t/t0060-path-utils.sh

··· 5 5 6 6 test_description='Test various path utilities' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 norm_path() {

-1

t/t0061-run-command.sh

··· 5 5 6 6 test_description='Test run command' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 cat >hello-script <<-EOF

-1

t/t0062-revision-walking.sh

··· 5 5 6 6 test_description='Test revision walking api' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 cat >run_twice_expected <<-EOF

-1

t/t0063-string-list.sh

··· 5 5 6 6 test_description='Test string list functionality' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_split () {

-1

t/t0066-dir-iterator.sh

··· 2 2 3 3 test_description='Test the dir-iterator functionality' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t0067-parse_pathspec_file.sh

··· 2 2 3 3 test_description='Test parse_pathspec_file()' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'one item from stdin' '

-1

t/t0068-for-each-repo.sh

··· 2 2 3 3 test_description='git for-each-repo builtin' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'run based on configured value' '

-1

t/t0070-fundamental.sh

··· 6 6 Verify wrappers and compatibility functions. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'mktemp to nonexistent directory prints filename' '

-1

t/t0071-sort.sh

··· 2 2 3 3 test_description='verify sort functions' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'DEFINE_LIST_SORT_DEBUG' '

-1

t/t0080-unit-test-output.sh

··· 2 2 3 3 test_description='Test the output of the unit test framework' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'TAP output from unit tests' - <<\EOT

-1

t/t0081-find-pack.sh

··· 2 2 3 3 test_description='test `test-tool find-pack`' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t0090-cache-tree.sh

··· 6 6 cache-tree extension. 7 7 " 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 cmp_cache_tree () {

-1

t/t0091-bugreport.sh

··· 2 2 3 3 test_description='git bugreport' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create a report' '

-1

t/t0092-diagnose.sh

··· 2 2 3 3 test_description='git diagnose' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success UNZIP 'creates diagnostics zip archive' '

+1 -2

t/t0095-bloom.sh

··· 2 2 3 3 test_description='Testing the various Bloom filter computations in bloom.c' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'compute unseeded murmur3 hash for empty string' ' ··· 77 76 test_cmp expect actual 78 77 ' 79 78 80 80 - test_expect_success !SANITIZE_LEAK 'get bloom filters for commit with no changes' ' 79 79 + test_expect_success 'get bloom filters for commit with no changes' ' 81 80 git init && 82 81 git commit --allow-empty -m "c0" && 83 82 cat >expect <<-\EOF &&

-1

t/t0100-previous.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'branch -d @{-1}' '

-1

t/t0101-at-syntax.sh

··· 2 2 3 3 test_description='various @{whatever} syntax tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t0200-gettext-basic.sh

··· 5 5 6 6 test_description='Gettext support for Git' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-gettext.sh 10 9 11 10 test_expect_success "sanity: \$GIT_INTERNAL_GETTEXT_SH_SCHEME is set (to $GIT_INTERNAL_GETTEXT_SH_SCHEME)" '

-1

t/t0201-gettext-fallbacks.sh

··· 8 8 GIT_INTERNAL_GETTEXT_TEST_FALLBACKS=YesPlease 9 9 export GIT_INTERNAL_GETTEXT_TEST_FALLBACKS 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./lib-gettext.sh 13 12 14 13 test_expect_success "sanity: \$GIT_INTERNAL_GETTEXT_SH_SCHEME is set (to $GIT_INTERNAL_GETTEXT_SH_SCHEME)" '

-1

t/t0202-gettext-perl.sh

··· 5 5 6 6 test_description='Perl gettext interface (Git::I18N)' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-gettext.sh 10 9 . "$TEST_DIRECTORY"/lib-perl.sh 11 10 skip_all_if_no_Test_More

-1

t/t0203-gettext-setlocale-sanity.sh

··· 5 5 6 6 test_description="The Git C functions aren't broken by setlocale(3)" 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-gettext.sh 10 9 11 10 test_expect_success 'git show a ISO-8859-1 commit under C locale' '

-1

t/t0204-gettext-reencode-sanity.sh

··· 5 5 6 6 test_description="Gettext reencoding of our *.po/*.mo files works" 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-gettext.sh 10 9 11 10 # The constants used in a tricky observation for undefined behaviour

-1

t/t0210-trace2-normal.sh

··· 2 2 3 3 test_description='test trace2 facility (normal target)' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Turn off any inherited trace2 settings for this test.

-1

t/t0211-trace2-perf.sh

··· 2 2 3 3 test_description='test trace2 facility (perf target)' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=false 6 5 . ./test-lib.sh 7 6 8 7 # Turn off any inherited trace2 settings for this test.

-1

t/t0212-trace2-event.sh

··· 2 2 3 3 test_description='test trace2 facility' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Turn off any inherited trace2 settings for this test.

-1

t/t0300-credentials.sh

··· 2 2 3 3 test_description='basic credential helper tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-credential.sh 8 7

-1

t/t0301-credential-cache.sh

··· 2 2 3 3 test_description='credential-cache tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-credential.sh 8 7

-1

t/t0302-credential-store.sh

··· 2 2 3 3 test_description='credential-store tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-credential.sh 8 7

-1

t/t0303-credential-external.sh

··· 29 29 commands. 30 30 ' 31 31 32 32 - TEST_PASSES_SANITIZE_LEAK=true 33 32 . ./test-lib.sh 34 33 . "$TEST_DIRECTORY"/lib-credential.sh 35 34

-1

t/t0410-partial-clone.sh

··· 2 2 3 3 test_description='partial clone' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-terminal.sh 8 7

-1

t/t0411-clone-from-partial.sh

··· 2 2 3 3 test_description='check that local clone does not fetch from promisor remotes' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create evil repo' '

-1

t/t0450-txt-doc-vs-help.sh

··· 5 5 Run this with --debug to see a summary of where we still fail to make 6 6 the two versions consistent with one another.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup: list of builtins' '

-1

t/t0500-progress-display.sh

··· 2 2 3 3 test_description='progress display' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 show_cr () {

-1

t/t0600-reffiles-backend.sh

··· 7 7 GIT_TEST_DEFAULT_REF_FORMAT=files 8 8 export GIT_TEST_DEFAULT_REF_FORMAT 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup' '

-1

t/t0601-reffiles-pack-refs.sh

··· 15 15 GIT_TEST_DEFAULT_REF_FORMAT=files 16 16 export GIT_TEST_DEFAULT_REF_FORMAT 17 17 18 18 - TEST_PASSES_SANITIZE_LEAK=true 19 18 . ./test-lib.sh 20 19 21 20 test_expect_success 'enable reflogs' '

-1

t/t0602-reffiles-fsck.sh

··· 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 GIT_TEST_DEFAULT_REF_FORMAT=files 8 8 export GIT_TEST_DEFAULT_REF_FORMAT 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 11 10 . ./test-lib.sh 12 11

-1

t/t0610-reftable-basics.sh

··· 10 10 GIT_TEST_DEFAULT_REF_FORMAT=reftable 11 11 export GIT_TEST_DEFAULT_REF_FORMAT 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 INVALID_OID=$(test_oid 001)

-1

t/t0611-reftable-httpd.sh

··· 2 2 3 3 test_description='reftable HTTPD tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-httpd.sh 8 7

-1

t/t0612-reftable-jgit-compatibility.sh

··· 11 11 GIT_TEST_SPLIT_INDEX=0 12 12 export GIT_TEST_SPLIT_INDEX 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 if ! test_have_prereq JGIT

-1

t/t0613-reftable-write-options.sh

··· 16 16 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master 17 17 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 18 18 19 19 - TEST_PASSES_SANITIZE_LEAK=true 20 19 . ./test-lib.sh 21 20 22 21 test_expect_success 'default write options' '

-1

t/t1000-read-tree-m-3way.sh

··· 72 72 73 73 ' 74 74 75 75 - TEST_PASSES_SANITIZE_LEAK=true 76 75 . ./test-lib.sh 77 76 . "$TEST_DIRECTORY"/lib-read-tree.sh 78 77 . "$TEST_DIRECTORY"/lib-read-tree-m-3way.sh

-1

t/t1001-read-tree-m-2way.sh

··· 21 21 yomin - not in H or M 22 22 ' 23 23 24 24 - TEST_PASSES_SANITIZE_LEAK=true 25 24 . ./test-lib.sh 26 25 . "$TEST_DIRECTORY"/lib-read-tree.sh 27 26

-1

t/t1002-read-tree-m-u-2way.sh

··· 9 9 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 . "$TEST_DIRECTORY"/lib-read-tree.sh 15 14

-1

t/t1003-read-tree-prefix.sh

··· 6 6 test_description='git read-tree --prefix test. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success setup '

-1

t/t1004-read-tree-m-u-wf.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-read-tree.sh 11 10

-1

t/t1005-read-tree-reset.sh

··· 2 2 3 3 test_description='read-tree -u --reset' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-read-tree.sh 8 7

-1

t/t1006-cat-file.sh

··· 2 2 3 3 test_description='git cat-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_cmdmode_usage () {

-1

t/t1007-hash-object.sh

··· 2 2 3 3 test_description="git hash-object" 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 echo_without_newline() {

-1

t/t1008-read-tree-overlay.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-read-tree.sh 11 10

-1

t/t1009-read-tree-new-index.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t1010-mktree.sh

··· 2 2 3 3 test_description='git mktree' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t1011-read-tree-sparse-checkout.sh

··· 12 12 ' 13 13 14 14 TEST_CREATE_REPO_NO_TEMPLATE=1 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 . "$TEST_DIRECTORY"/lib-read-tree.sh 18 17

-1

t/t1012-read-tree-df.sh

··· 2 2 3 3 test_description='read-tree D/F conflict corner cases' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-read-tree.sh 8 7

-1

t/t1013-read-tree-submodule.sh

··· 2 2 3 3 test_description='read-tree can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t1014-read-tree-confusing.sh

··· 2 2 3 3 test_description='check that read-tree rejects confusing paths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create base tree' '

-1

t/t1015-read-index-unmerged.sh

··· 2 2 3 3 test_description='Test various callers of read_index_unmerged' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup modify/delete + directory/file conflict' '

-1

t/t1016-compatObjectFormat.sh

··· 5 5 6 6 test_description='Test how well compatObjectFormat works' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-gpg.sh 11 10

-1

t/t1020-subdirectory.sh

··· 6 6 test_description='Try various core-level commands in subdirectory. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 . "$TEST_DIRECTORY"/lib-read-tree.sh 12 11

-1

t/t1021-rerere-in-workdir.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success SYMLINKS setup '

-1

t/t1022-read-tree-partial-clone.sh

··· 3 3 test_description='git read-tree in partial clones' 4 4 5 5 TEST_NO_CREATE_REPO=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'read-tree in partial clone prefetches in one batch' '

-1

t/t1050-large.sh

··· 3 3 4 4 test_description='adding and checking out large blobs' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'core.bigFileThreshold must be non-negative' '

-1

t/t1051-large-conversion.sh

··· 2 2 3 3 test_description='test conversion filters on large files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 set_attr() {

-1

t/t1060-object-corruption.sh

··· 2 2 3 3 test_description='see how we handle various forms of corruption' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # convert "1234abcd" to ".git/objects/12/34abcd"

-1

t/t1090-sparse-checkout-scope.sh

··· 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 TEST_CREATE_REPO_NO_TEMPLATE=1 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'setup' '

-1

t/t1091-sparse-checkout-builtin.sh

··· 8 8 GIT_TEST_SPLIT_INDEX=false 9 9 export GIT_TEST_SPLIT_INDEX 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 list_files() {

-1

t/t1092-sparse-checkout-compatibility.sh

··· 5 5 GIT_TEST_SPLIT_INDEX=0 6 6 GIT_TEST_SPARSE_INDEX= 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t1100-commit-tree-options.sh

··· 12 12 "flags first and then non flag arguments" command line. 13 13 ' 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 cat >expected <<EOF

-1

t/t1300-config.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 for mode in legacy subcommands

-1

t/t1301-shared-repo.sh

··· 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 TEST_CREATE_REPO_NO_TEMPLATE=1 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 # Remove a default ACL from the test dir if possible.

-1

t/t1302-repo-version.sh

··· 5 5 6 6 test_description='Test repository version check' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t1303-wacky-config.sh

··· 2 2 3 3 test_description='Test wacky input to git config' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Leaving off the newline is intentional!

-1

t/t1304-default-acl.sh

··· 9 9 # => this must come before . ./test-lib.sh 10 10 umask 077 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 # We need an arbitrary other user give permission to using ACLs. root

-1

t/t1305-config-include.sh

··· 1 1 #!/bin/sh 2 2 3 3 test_description='test config file include directives' 4 4 - TEST_PASSES_SANITIZE_LEAK=true 5 4 . ./test-lib.sh 6 5 7 6 # Force setup_explicit_git_dir() to run until the end. This is needed

-1

t/t1306-xdg-files.sh

··· 7 7 8 8 test_description='Compatibility with $XDG_CONFIG_HOME/git/ files' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'read config: xdg file exists and ~/.gitconfig doesn'\''t' '

-1

t/t1307-config-blob.sh

··· 2 2 3 3 test_description='support for reading config from a blob' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create config blob' '

-1

t/t1308-config-set.sh

··· 2 2 3 3 test_description='Test git config-set API in different settings' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # 'check_config get_* section.key value' verifies that the entry for

-1

t/t1309-early-config.sh

··· 2 2 3 3 test_description='Test read_early_config()' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'read early config' '

-1

t/t1310-config-default.sh

··· 2 2 3 3 test_description='Test git config in different settings (with --default)' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'uses --default when entry missing' '

-1

t/t1350-config-hooks-path.sh

··· 2 2 3 3 test_description='Test the core.hooksPath configuration variable' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up a pre-commit hook in core.hooksPath' '

-1

t/t1400-update-ref.sh

··· 5 5 6 6 test_description='Test git update-ref and basic ref logging' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 Z=$ZERO_OID

-1

t/t1401-symbolic-ref.sh

··· 2 2 3 3 test_description='basic symbolic-ref tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # If the tests munging HEAD fail, they can break detection of

-1

t/t1402-check-ref-format.sh

··· 2 2 3 3 test_description='Test git check-ref-format' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 valid_ref() {

-1

t/t1403-show-ref.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t1404-update-ref-errors.sh

··· 2 2 3 3 test_description='Test git update-ref error handling' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Create some references, perhaps run pack-refs --all, then try to

-1

t/t1405-main-ref-store.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 RUN="test-tool ref-store main"

-1

t/t1406-submodule-ref-store.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 RUN="test-tool ref-store submodule:sub"

-1

t/t1407-worktree-ref-store.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 RWT="test-tool ref-store worktree:wt"

-1

t/t1408-packed-refs.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t1409-avoid-packing-refs.sh

··· 2 2 3 3 test_description='avoid rewriting packed-refs unnecessarily' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if test_have_prereq !REFFILES

-1

t/t1410-reflog.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 check_have () {

-1

t/t1411-reflog-show.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t1412-reflog-loop.sh

··· 2 2 3 3 test_description='reflog walk shows repeated commits again' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup commits' '

-1

t/t1413-reflog-detach.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 reset_state () {

-1

t/t1414-reflog-walk.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'set up some reflog entries' '

-1

t/t1415-worktree-refs.sh

··· 2 2 3 3 test_description='per-worktree refs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t1416-ref-transaction-hooks.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t1417-reflog-updateref.sh

··· 2 2 3 3 test_description='git reflog --updateref' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t1418-reflog-exists.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t1419-exclude-refs.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 for_each_ref__exclude () {

-1

t/t1420-lost-found.sh

··· 5 5 6 6 test_description='Test fsck --lost-found' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t1430-bad-ref-name.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t1450-fsck.sh

··· 6 6 * (main) A 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success setup '

-1

t/t1451-fsck-buffer.sh

··· 15 15 ASan or valgrind for more confidence. 16 16 ' 17 17 18 18 - TEST_PASSES_SANITIZE_LEAK=true 19 18 . ./test-lib.sh 20 19 21 20 # the general idea for tags and commits is to build up the "base" file

-1

t/t1460-refs-migrate.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_migration () {

-1

t/t1500-rev-parse.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_one () {

-1

t/t1501-work-tree.sh

··· 2 2 3 3 test_description='test separate work tree' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t1502-rev-parse-parseopt.sh

··· 2 2 3 3 test_description='test git rev-parse --parseopt' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 check_invalid_long_option () {

-1

t/t1503-rev-parse-verify.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 add_line_into_file()

-1

t/t1504-ceiling-dirs.sh

··· 2 2 3 3 test_description='test GIT_CEILING_DIRECTORIES' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_prefix() {

-1

t/t1505-rev-parse-last.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t1506-rev-parse-diagnosis.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_did_you_mean ()

-1

t/t1507-rev-parse-upstream.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t1508-at-combinations.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 check() {

-1

t/t1510-repo-setup.sh

··· 43 43 # This test heavily relies on the standard error of nested function calls. 44 44 test_untraceable=UnfortunatelyYes 45 45 46 46 - TEST_PASSES_SANITIZE_LEAK=true 47 46 . ./test-lib.sh 48 47 49 48 here=$(pwd)

-1

t/t1511-rev-parse-caret.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t1512-rev-parse-disambiguation.sh

··· 23 23 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 24 24 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 25 25 26 26 - TEST_PASSES_SANITIZE_LEAK=true 27 26 . ./test-lib.sh 28 27 29 28 test_cmp_failed_rev_parse () {

-1

t/t1513-rev-parse-prefix.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t1514-rev-parse-push.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 resolve () {

-1

t/t1515-rev-parse-outside-repo.sh

··· 2 2 3 3 test_description='check that certain rev-parse options work outside repo' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up non-repo directory' '

-1

t/t1517-outside-repo.sh

··· 2 2 3 3 test_description='check random commands outside repo' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up a non-repo directory and test file' '

-1

t/t1600-index.sh

··· 2 2 3 3 test_description='index file specific tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 sane_unset GIT_TEST_SPLIT_INDEX

-1

t/t1601-index-bogus.sh

··· 2 2 3 3 test_description='test handling of bogus index entries' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create tree with null sha1' '

-1

t/t1701-racy-split-index.sh

··· 5 5 6 6 test_description='racy split index' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t1800-hook.sh

··· 2 2 3 3 test_description='git-hook command' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-terminal.sh 8 7

-1

t/t2000-conflict-when-checking-files-out.sh

··· 21 21 # path1 is occupied by a non-directory. With "-f" flag, it should remove 22 22 # the conflicting paths and succeed. 23 23 24 24 - TEST_PASSES_SANITIZE_LEAK=true 25 24 . ./test-lib.sh 26 25 27 26 show_files() {

-1

t/t2002-checkout-cache-u.sh

··· 8 8 With -u flag, git checkout-index internally runs the equivalent of 9 9 git update-index --refresh on the checked out entry.' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success \

-1

t/t2003-checkout-cache-mkdir.sh

··· 10 10 the GIT controlled paths. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 test_expect_success 'setup' '

-1

t/t2004-checkout-cache-temp.sh

··· 8 8 With --temp flag, git checkout-index writes to temporary merge files 9 9 rather than the tracked path.' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success 'setup' '

-1

t/t2005-checkout-index-symlinks.sh

··· 8 8 This tests that git checkout-index creates a symbolic link as a plain 9 9 file if core.symlinks is false.' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success \

-1

t/t2006-checkout-index-basic.sh

··· 3 3 test_description='basic checkout-index tests 4 4 ' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'checkout-index --gobbledegook' '

-1

t/t2007-checkout-symlink.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t2008-checkout-subdir.sh

··· 4 4 5 5 test_description='git checkout from subdirectories' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t2009-checkout-statinfo.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2010-checkout-ambiguous.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2011-checkout-invalid-head.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2012-checkout-last.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2013-checkout-submodule.sh

··· 2 2 3 3 test_description='checkout can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t2014-checkout-switch.sh

··· 2 2 3 3 test_description='Peter MacMillan' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t2015-checkout-unborn.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t2016-checkout-patch.sh

··· 2 2 3 3 test_description='git checkout --patch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-patch-mode.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2017-checkout-orphan.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 TEST_FILE=foo

-1

t/t2018-checkout-branch.sh

··· 3 3 test_description='checkout' 4 4 5 5 TEST_CREATE_REPO_NO_TEMPLATE=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 # Arguments: [!] <branch> <oid> [<checkout options>]

-1

t/t2019-checkout-ambiguous-ref.sh

··· 2 2 3 3 test_description='checkout handling of ambiguous (branch/tag) refs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup ambiguous refs' '

-1

t/t2020-checkout-detach.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 check_detached () {

-1

t/t2021-checkout-overwrite.sh

··· 2 2 3 3 test_description='checkout must not overwrite an untracked objects' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2022-checkout-paths.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t2023-checkout-m.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t2024-checkout-dwim.sh

··· 4 4 5 5 Ensures that checkout on an unborn branch does what the user expects' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # Is the current branch "refs/heads/$1"?

-1

t/t2025-checkout-no-overlay.sh

··· 2 2 3 3 test_description='checkout --no-overlay <tree-ish> -- <pathspec>' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2026-checkout-pathspec-file.sh

··· 2 2 3 3 test_description='checkout --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t2027-checkout-track.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2030-unresolve-info.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 check_resolve_undo () {

-1

t/t2050-git-dir-relative.sh

··· 12 12 and tries commits from the top and the subdir, checking 13 13 that the commit-hook still gets called.' 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 COMMIT_FILE="$(pwd)/output"

-1

t/t2060-switch.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2070-restore.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2071-restore-patch.sh

··· 2 2 3 3 test_description='git restore --patch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-patch-mode.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2072-restore-pathspec-file.sh

··· 2 2 3 3 test_description='restore --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t2080-parallel-checkout-basics.sh

··· 8 8 ' 9 9 10 10 TEST_NO_CREATE_REPO=1 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY/lib-parallel-checkout.sh" 14 13

-1

t/t2081-parallel-checkout-collisions.sh

··· 11 11 both these mechanics. 12 12 " 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 . "$TEST_DIRECTORY/lib-parallel-checkout.sh" 17 16

-1

t/t2082-parallel-checkout-attributes.sh

··· 10 10 ' 11 11 12 12 TEST_NO_CREATE_REPO=1 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY/lib-parallel-checkout.sh" 16 15 . "$TEST_DIRECTORY/lib-encoding.sh"

-1

t/t2100-update-cache-badpath.sh

··· 22 22 All of the attempts should fail. 23 23 ' 24 24 25 25 - TEST_PASSES_SANITIZE_LEAK=true 26 25 . ./test-lib.sh 27 26 28 27 mkdir path2 path3

-1

t/t2101-update-index-reupdate.sh

··· 6 6 test_description='git update-index --again test. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'update-index --add' '

-1

t/t2102-update-index-symlinks.sh

··· 8 8 This tests that git update-index keeps the symbolic link property 9 9 even if a plain file is in the working tree if core.symlinks is false.' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success \

-1

t/t2103-update-index-ignore-missing.sh

··· 2 2 3 3 test_description='update-index with options' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success basics '

-1

t/t2104-update-index-skip-worktree.sh

··· 5 5 6 6 test_description='skip-worktree bit test' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 sane_unset GIT_TEST_SPLIT_INDEX

-1

t/t2105-update-index-gitfile.sh

··· 6 6 test_description='git update-index for gitlink to .git file. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'submodule with absolute .git file' '

-1

t/t2106-update-index-assume-unchanged.sh

··· 3 3 test_description='git update-index --assume-unchanged test. 4 4 ' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'setup' '

-1

t/t2107-update-index-basic.sh

··· 5 5 Tests for command-line parsing and basic operation. 6 6 ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'update-index --nonsense fails' '

-1

t/t2108-update-index-refresh-racy.sh

··· 2 2 3 3 test_description='update-index refresh tests related to racy timestamps' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 reset_files () {

-1

t/t2200-add-update.sh

··· 14 14 Also tested are "git add -u" without limiting, and "git add -u" 15 15 without contents changes, and other conditions' 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 test_expect_success setup '

-1

t/t2201-add-update-typechange.sh

··· 2 2 3 3 test_description='more git add -u' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t2202-add-addremove.sh

··· 2 2 3 3 test_description='git add --all' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t2203-add-intent.sh

··· 2 2 3 3 test_description='Intent to add' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'intent to add' '

-1

t/t2204-add-ignored.sh

··· 2 2 3 3 test_description='giving ignored paths to git add' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t2205-add-worktree-config.sh

··· 17 17 repository can be added to the index. 18 18 ' 19 19 20 20 - TEST_PASSES_SANITIZE_LEAK=true 21 20 . ./test-lib.sh 22 21 23 22 test_expect_success '1a: setup--config worktree' '

-1

t/t2300-cd-to-toplevel.sh

··· 2 2 3 3 test_description='cd_to_toplevel' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 EXEC_PATH="$(git --exec-path)"

-1

t/t2400-worktree-add.sh

··· 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 TEST_CREATE_REPO_NO_TEMPLATE=1 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t2401-worktree-prune.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success initialize '

-1

t/t2402-worktree-list.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t2403-worktree-move.sh

··· 2 2 3 3 test_description='test git worktree move, remove, lock and unlock' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2404-worktree-config.sh

··· 2 2 3 3 test_description="config file in multi worktree" 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t2405-worktree-submodule.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 base_path=$(pwd -P)

-1

t/t2406-worktree-repair.sh

··· 2 2 3 3 test_description='test git worktree repair' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

+8 -9

t/t2407-worktree-heads.sh

··· 2 2 3 3 test_description='test operations trying to overwrite refs at worktree HEAD' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' ' ··· 49 48 done 50 49 ' 51 50 52 52 - test_expect_success !SANITIZE_LEAK 'refuse to overwrite: worktree in bisect' ' 51 51 + test_expect_success 'refuse to overwrite: worktree in bisect' ' 53 52 test_when_finished git -C wt-4 bisect reset && 54 53 55 54 # Set up a bisect so HEAD no longer points to wt-4. ··· 61 60 grep "cannot force update the branch '\''wt-4'\'' used by worktree at.*wt-4" err 62 61 ' 63 62 64 64 - test_expect_success !SANITIZE_LEAK 'refuse to overwrite: worktree in rebase (apply)' ' 63 63 + test_expect_success 'refuse to overwrite: worktree in rebase (apply)' ' 65 64 test_when_finished git -C wt-2 rebase --abort && 66 65 67 66 # This will fail part-way through due to a conflict. ··· 71 70 grep "cannot force update the branch '\''wt-2'\'' used by worktree at.*wt-2" err 72 71 ' 73 72 74 74 - test_expect_success !SANITIZE_LEAK 'refuse to overwrite: worktree in rebase (merge)' ' 73 73 + test_expect_success 'refuse to overwrite: worktree in rebase (merge)' ' 75 74 test_when_finished git -C wt-2 rebase --abort && 76 75 77 76 # This will fail part-way through due to a conflict. ··· 81 80 grep "cannot force update the branch '\''wt-2'\'' used by worktree at.*wt-2" err 82 81 ' 83 82 84 84 - test_expect_success !SANITIZE_LEAK 'refuse to overwrite: worktree in rebase with --update-refs' ' 83 83 + test_expect_success 'refuse to overwrite: worktree in rebase with --update-refs' ' 85 84 test_when_finished git -C wt-3 rebase --abort && 86 85 87 86 git branch -f can-be-updated wt-3 && ··· 95 94 done 96 95 ' 97 96 98 98 - test_expect_success !SANITIZE_LEAK 'refuse to fetch over ref: checked out' ' 97 97 + test_expect_success 'refuse to fetch over ref: checked out' ' 99 98 test_must_fail git fetch server +refs/heads/wt-3:refs/heads/wt-3 2>err && 100 99 grep "refusing to fetch into branch '\''refs/heads/wt-3'\''" err && 101 100 ··· 105 104 grep "refusing to fetch into branch" err 106 105 ' 107 106 108 108 - test_expect_success !SANITIZE_LEAK 'refuse to fetch over ref: worktree in bisect' ' 107 107 + test_expect_success 'refuse to fetch over ref: worktree in bisect' ' 109 108 test_when_finished git -C wt-4 bisect reset && 110 109 111 110 # Set up a bisect so HEAD no longer points to wt-4. ··· 117 116 grep "refusing to fetch into branch" err 118 117 ' 119 118 120 120 - test_expect_success !SANITIZE_LEAK 'refuse to fetch over ref: worktree in rebase' ' 119 119 + test_expect_success 'refuse to fetch over ref: worktree in rebase' ' 121 120 test_when_finished git -C wt-3 rebase --abort && 122 121 123 122 # This will fail part-way through due to a conflict. ··· 157 156 158 157 . "$TEST_DIRECTORY"/lib-rebase.sh 159 158 160 160 - test_expect_success !SANITIZE_LEAK 'refuse to overwrite during rebase with --update-refs' ' 159 159 + test_expect_success 'refuse to overwrite during rebase with --update-refs' ' 161 160 git commit --fixup HEAD~2 --allow-empty && 162 161 ( 163 162 set_cat_todo_editor &&

-1

t/t2408-worktree-relative.sh

··· 2 2 3 3 test_description='test worktrees linked with relative paths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'links worktrees with relative paths' '

-1

t/t2500-untracked-overwriting.sh

··· 2 2 3 3 test_description='Test handling of overwriting untracked files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_setup_reset () {

-1

t/t2501-cwd-empty.sh

··· 2 2 3 3 test_description='Test handling of the current working directory becoming empty' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t3000-ls-files-others.sh

··· 16 16 path4 - an empty directory 17 17 ' 18 18 19 19 - TEST_PASSES_SANITIZE_LEAK=true 20 19 . ./test-lib.sh 21 20 22 21 test_expect_success 'setup ' '

-1

t/t3001-ls-files-others-exclude.sh

··· 8 8 This test runs git ls-files --others and tests --exclude patterns. 9 9 ' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 rm -fr one three

-1

t/t3002-ls-files-dashpath.sh

··· 13 13 -- - another file with a funny name. 14 14 ' 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./test-lib.sh 18 17 19 18 test_expect_success 'setup' '

-1

t/t3003-ls-files-exclude.sh

··· 2 2 3 3 test_description='ls-files --exclude does not affect index files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create repo with file' '

-1

t/t3004-ls-files-basic.sh

··· 6 6 command-line arguments. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'ls-files in empty repository' '

-1

t/t3005-ls-files-relative.sh

··· 5 5 This test runs git ls-files with various relative path arguments. 6 6 ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'prepare' '

-1

t/t3006-ls-files-long.sh

··· 2 2 3 3 test_description='overly long paths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t3007-ls-files-recurse-submodules.sh

··· 6 6 submodules. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'setup directory structure and submodules' '

-1

t/t3008-ls-files-lazy-init-name-hash.sh

··· 2 2 3 3 test_description='Test the lazy init name hash with various folder structures' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if test 1 -eq $(test-tool online-cpus)

-1

t/t3009-ls-files-others-nonsubmodule.sh

··· 18 18 git repository with a commit and an untracked file 19 19 ' 20 20 21 21 - TEST_PASSES_SANITIZE_LEAK=true 22 21 . ./test-lib.sh 23 22 24 23 test_expect_success 'setup: directories' '

-1

t/t3010-ls-files-killed-modified.sh

··· 42 42 modified without reporting path9 and path10. submod1 is also modified. 43 43 ' 44 44 45 45 - TEST_PASSES_SANITIZE_LEAK=true 46 45 . ./test-lib.sh 47 46 48 47 test_expect_success 'git update-index --add to add various paths.' '

-1

t/t3011-common-prefixes-and-directory-traversal.sh

··· 2 2 3 3 test_description='directory traversal handling, especially with common prefixes' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3012-ls-files-dedup.sh

··· 2 2 3 3 test_description='git ls-files --deduplicate test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3013-ls-files-format.sh

··· 2 2 3 3 test_description='git ls-files --format test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 for flag in -s -o -k -t --resolve-undo --deduplicate --eol

-1

t/t3020-ls-files-error-unmatch.sh

··· 10 10 line. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 test_expect_success 'setup' '

-1

t/t3040-subprojects-basic.sh

··· 2 2 3 3 test_description='Basic subproject functionality' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup: create superproject' '

-1

t/t3050-subprojects-fetch.sh

··· 2 2 3 3 test_description='fetching and pushing project with subproject' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t3060-ls-files-with-tree.sh

··· 9 9 a scenario known to trigger a crash with some versions of git. 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'setup' '

-1

t/t3070-wildmatch.sh

··· 2 2 3 3 test_description='wildmatch tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 should_create_test_file() {

-1

t/t3100-ls-tree-restrict.sh

··· 17 17 path2/baz. Also path0/ should snow nothing. 18 18 ' 19 19 20 20 - TEST_PASSES_SANITIZE_LEAK=true 21 20 . ./test-lib.sh 22 21 23 22 test_expect_success \

-1

t/t3101-ls-tree-dirname.sh

··· 20 20 entries. Also test odd filename and missing entries handling. 21 21 ' 22 22 23 23 - TEST_PASSES_SANITIZE_LEAK=true 24 23 . ./test-lib.sh 25 24 26 25 test_expect_success 'setup' '

-1

t/t3102-ls-tree-wildcards.sh

··· 2 2 3 3 test_description='ls-tree with(out) globs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3103-ls-tree-misc.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup' '

-1

t/t3104-ls-tree-format.sh

··· 2 2 3 3 test_description='ls-tree --format' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-t3100.sh 8 7

-1

t/t3105-ls-tree-output.sh

··· 2 2 3 3 test_description='ls-tree output' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-t3100.sh 8 7

-1

t/t3200-branch.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-rebase.sh 14 13

-1

t/t3201-branch-contains.sh

··· 2 2 3 3 test_description='branch --contains <commit>, --no-contains <commit> --merged, and --no-merged' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t3202-show-branch.sh

··· 2 2 3 3 test_description='test show-branch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'error descriptions on empty repository' '

-1

t/t3203-branch-output.sh

··· 2 2 3 3 test_description='git branch display tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-terminal.sh 8 7

-1

t/t3204-branch-name-interpretation.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 expect_branch() {

-1

t/t3205-branch-color.sh

··· 1 1 #!/bin/sh 2 2 3 3 test_description='basic branch output coloring' 4 4 - TEST_PASSES_SANITIZE_LEAK=true 5 4 . ./test-lib.sh 6 5 7 6 test_expect_success 'set up some sample branches' '

-1

t/t3206-range-diff.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Note that because of the range-diff's heuristics, test_commit does more

-1

t/t3207-branch-submodule.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-rebase.sh 11 10

-1

t/t3211-peel-ref.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'create annotated tag in refs/tags' '

-1

t/t3300-funny-names.sh

··· 9 9 tree, index, and tree objects. 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 HT=' '

-1

t/t3301-notes.sh

··· 5 5 6 6 test_description='Test commit notes' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 write_script fake_editor <<\EOF

-1

t/t3302-notes-index-expensive.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 create_repo () {

-1

t/t3303-notes-subtrees.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 number_of_commits=100

-1

t/t3304-notes-mixed.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 number_of_commits=100

-1

t/t3305-notes-fanout.sh

··· 2 2 3 3 test_description='Test that adding/removing many notes triggers automatic fanout restructuring' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 path_has_fanout() {

-1

t/t3306-notes-prune.sh

··· 2 2 3 3 test_description='Test git notes prune' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup: create a few commits with notes' '

-1

t/t3307-notes-man.sh

··· 4 4 5 5 Make sure the manual is not full of lies.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t3308-notes-merge.sh

··· 5 5 6 6 test_description='Test merging of notes trees' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3309-notes-merge-auto-resolve.sh

··· 5 5 6 6 test_description='Test notes merging with auto-resolving strategies' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Set up a notes merge scenario with all kinds of potential conflicts

-1

t/t3310-notes-merge-manual-resolve.sh

··· 5 5 6 6 test_description='Test notes merging with manual conflict resolution' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Set up a notes merge scenario with different kinds of conflicts

-1

t/t3311-notes-merge-fanout.sh

··· 5 5 6 6 test_description='Test notes merging at various fanout levels' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 verify_notes () {

-1

t/t3320-notes-merge-worktrees.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success 'setup commit' '

-1

t/t3321-notes-stripspace.sh

··· 5 5 6 6 test_description='Test commit notes with stripspace behavior' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 MULTI_LF="$LF$LF$LF"

-1

t/t3400-rebase.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 GIT_AUTHOR_NAME=author@name

-1

t/t3401-rebase-and-am-rename.sh

··· 2 2 3 3 test_description='git rebase + directory rename tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-rebase.sh 8 7

-1

t/t3402-rebase-merge.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 T="A quick brown fox

-1

t/t3403-rebase-skip.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3404-rebase-interactive.sh

··· 26 26 touch file "conflict". 27 27 ' 28 28 29 29 - TEST_PASSES_SANITIZE_LEAK=true 30 29 . ./test-lib.sh 31 30 32 31 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3405-rebase-malformed.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-rebase.sh 11 10

-1

t/t3406-rebase-message.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t3407-rebase-abort.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3408-rebase-multi-line.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3409-rebase-environ.sh

··· 2 2 3 3 test_description='git rebase interactive environment' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3412-rebase-root.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 log_with_names () {

-1

t/t3413-rebase-hook.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3415-rebase-autosquash.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3416-rebase-onto-threedots.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY/lib-rebase.sh" 11 10

-1

t/t3417-rebase-whitespace-fix.sh

··· 5 5 This test runs git rebase --whitespace=fix and make sure that it works. 6 6 ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # prepare initial revision of "file" with a blank line at the end

-1

t/t3418-rebase-continue.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3419-rebase-patch-id.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 scramble () {

-1

t/t3420-rebase-autostash.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t3421-rebase-topology-linear.sh

··· 2 2 3 3 test_description='basic rebase topology tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-rebase.sh 8 7

-1

t/t3422-rebase-incompatible-options.sh

··· 2 2 3 3 test_description='test if rebase detects and aborts on incompatible options' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3423-rebase-reword.sh

··· 2 2 3 3 test_description='git rebase interactive with rewording' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3424-rebase-empty.sh

··· 2 2 3 3 test_description='git rebase of commits that start or become empty' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup test repository' '

-1

t/t3425-rebase-topology-merges.sh

··· 2 2 3 3 test_description='rebase topology tests with merges' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-rebase.sh 8 7

-1

t/t3426-rebase-submodule.sh

··· 2 2 3 3 test_description='rebase can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3427-rebase-subtree.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-rebase.sh 13 12

-1

t/t3428-rebase-signoff.sh

··· 5 5 This test runs git rebase --signoff and make sure that it works. 6 6 ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-rebase.sh 11 10

-1

t/t3429-rebase-edit-todo.sh

··· 2 2 3 3 test_description='rebase should reread the todo file if an exec modifies it' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-rebase.sh 8 7

-1

t/t3430-rebase-merges.sh

··· 21 21 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 22 22 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 23 23 24 24 - TEST_PASSES_SANITIZE_LEAK=true 25 24 . ./test-lib.sh 26 25 . "$TEST_DIRECTORY"/lib-rebase.sh 27 26 . "$TEST_DIRECTORY"/lib-log-graph.sh

-1

t/t3431-rebase-fork-point.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 # A---B---D---E (main)

-1

t/t3432-rebase-fast-forward.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t3433-rebase-across-mode-change.sh

··· 2 2 3 3 test_description='git rebase across mode change' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3434-rebase-i18n.sh

··· 17 17 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 18 18 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 19 19 20 20 - TEST_PASSES_SANITIZE_LEAK=true 21 20 . ./test-lib.sh 22 21 23 22 if ! test_have_prereq ICONV

-1

t/t3435-rebase-gpg-sign.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY/lib-rebase.sh" 14 13 . "$TEST_DIRECTORY/lib-gpg.sh"

-1

t/t3436-rebase-more-options.sh

··· 5 5 6 6 test_description='tests to ensure compatibility between am and interactive backends' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3437-rebase-fixup-options.sh

··· 14 14 "amend!" upon --autosquash. 15 15 ' 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t3438-rebase-broken-files.sh

··· 2 2 3 3 test_description='rebase behavior when on-disk files are broken' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up conflicting branches' '

-1

t/t3500-cherry.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 GIT_AUTHOR_EMAIL=bogus_email_address

-1

t/t3501-revert-cherry-pick.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3502-cherry-pick-merge.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 test_expect_success setup '

-1

t/t3503-cherry-pick-root.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3504-cherry-pick-rerere.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3505-cherry-pick-empty.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3506-cherry-pick-ff.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t3507-cherry-pick-conflict.sh

··· 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 TEST_CREATE_REPO_NO_TEMPLATE=1 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./test-lib.sh 18 17 19 18 pristine_detach () {

-1

t/t3508-cherry-pick-many-commits.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 check_head_differs_from() {

-1

t/t3509-cherry-pick-merge-df.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'Initialize repository' '

-1

t/t3510-cherry-pick-sequence.sh

··· 12 12 13 13 ' 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 # Repeat first match 10 times

-1

t/t3511-cherry-pick-x.sh

··· 2 2 3 3 test_description='Test cherry-pick -x and -s' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 pristine_detach () {

-1

t/t3512-cherry-pick-submodule.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-submodule-update.sh 11 10

-1

t/t3513-revert-submodule.sh

··· 2 2 3 3 test_description='revert can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t3514-cherry-pick-revert-gpg.sh

··· 5 5 6 6 test_description='test {cherry-pick,revert} --[no-]gpg-sign' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY/lib-gpg.sh" 11 10

-1

t/t3600-rm.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 # Setup some files to be removed, some with funny characters

-1

t/t3601-rm-pathspec-file.sh

··· 2 2 3 3 test_description='rm --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t3602-rm-sparse-checkout.sh

··· 2 2 3 3 test_description='git rm in sparse checked out working trees' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' "

-1

t/t3650-replay-basics.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 GIT_AUTHOR_NAME=author@name

-1

t/t3700-add.sh

··· 5 5 6 6 test_description='Test of git add, including the -- option.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 . "$TEST_DIRECTORY"/lib-unique-files.sh

-1

t/t3701-add-interactive.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-terminal.sh 10 9

-1

t/t3702-add-edit.sh

··· 5 5 6 6 test_description='add -e basic tests' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t3703-add-magic-pathspec.sh

··· 2 2 3 3 test_description='magic pathspec tests using git-add' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3704-add-pathspec-file.sh

··· 2 2 3 3 test_description='add --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t3705-add-sparse-checkout.sh

··· 2 2 3 3 test_description='git add in sparse checked out working trees' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 SPARSE_ENTRY_BLOB=""

-1

t/t3800-mktag.sh

··· 4 4 5 5 test_description='git mktag: tag object verify test' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 ###########################################################

-1

t/t3900-i18n-commit.sh

··· 5 5 6 6 test_description='commit and log output encodings' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 if ! test_have_prereq ICONV

-1

t/t3901-i18n-patch.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 if ! test_have_prereq ICONV

-1

t/t3902-quoted.sh

··· 5 5 6 6 test_description='quoted output' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 FN='濱野'

-1

t/t3903-stash.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-unique-files.sh 14 13

-1

t/t3904-stash-patch.sh

··· 2 2 3 3 test_description='stash -p' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-patch-mode.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3905-stash-include-untracked.sh

··· 5 5 6 6 test_description='Test git stash --include-untracked' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'stash save --include-untracked some dirty working directory' '

-1

t/t3906-stash-submodule.sh

··· 2 2 3 3 test_description='stash can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t3907-stash-show-config.sh

··· 2 2 3 3 test_description='Test git stash show configuration.' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t3908-stash-in-worktree.sh

··· 5 5 6 6 test_description='Test git stash in a worktree' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t3909-stash-pathspec-file.sh

··· 2 2 3 3 test_description='stash --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t3920-crlf-messages.sh

··· 2 2 3 3 test_description='Test ref-filter and pretty APIs for commit and tag messages using CRLF' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 LIB_CRLF_BRANCHES=""

-1

t/t4000-diff-format.sh

··· 10 10 diff-files as a representative. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY"/lib-diff.sh 16 15

-1

t/t4001-diff-rename.sh

··· 5 5 6 6 test_description='Test rename detection in diff engine.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-diff.sh 11 10

-1

t/t4002-diff-basic.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 . "$TEST_DIRECTORY"/lib-read-tree-m-3way.sh

-1

t/t4003-diff-rename-1.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 13 12

-1

t/t4004-diff-rename-symlink.sh

··· 10 10 by an edit for them. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY"/lib-diff.sh 16 15

-1

t/t4005-diff-rename-2.sh

··· 6 6 test_description='Same rename detection as t4003 but testing diff-raw.' 7 7 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 12 11

-1

t/t4006-diff-mode.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 sed_script='s/\(:100644 100755\) \('"$OID_REGEX"'\) \2 /\1 X X /'

-1

t/t4007-rename-3.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 13 12

-1

t/t4008-diff-break-rewrite.sh

··· 22 22 Further, with -B and -M together, these should turn into two renames. 23 23 ' 24 24 25 25 - TEST_PASSES_SANITIZE_LEAK=true 26 25 . ./test-lib.sh 27 26 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 28 27

-1

t/t4009-diff-rename-4.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 13 12

-1

t/t4010-diff-pathspec.sh

··· 10 10 path1/file1 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 16 15

-1

t/t4011-diff-symlink.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh 13 12

-1

t/t4012-diff-binary.sh

··· 6 6 test_description='Binary diff and apply 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 cat >expect.binary-numstat <<\EOF

-1

t/t4013-diff-various.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-diff.sh 14 13

-1

t/t4014-format-patch.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-terminal.sh 14 13

-1

t/t4015-diff-whitespace.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh 13 12

-1

t/t4016-diff-quote.sh

··· 6 6 test_description='Quoting paths in diff output. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 P0='pathname'

-1

t/t4017-diff-retval.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4018-diff-funcname.sh

··· 5 5 6 6 test_description='Test custom diff function name patterns' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4019-diff-wserror.sh

··· 2 2 3 3 test_description='diff whitespace error detection' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

+2 -3

t/t4020-diff-external.sh

··· 2 2 3 3 test_description='external diff interface test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup ' ··· 102 101 test_cmp expect actual 103 102 ' 104 103 105 105 - test_expect_success !SANITIZE_LEAK 'diff attribute should apply only to diff' ' 104 104 + test_expect_success 'diff attribute should apply only to diff' ' 106 105 git log -p -1 HEAD >out && 107 106 grep "^diff --git a/file b/file" out 108 107 ··· 129 128 test_cmp expect actual 130 129 ' 131 130 132 132 - test_expect_success !SANITIZE_LEAK 'diff attribute should apply only to diff' ' 131 131 + test_expect_success 'diff attribute should apply only to diff' ' 133 132 git log -p -1 HEAD >out && 134 133 grep "^diff --git a/file b/file" out 135 134

-1

t/t4021-format-patch-numbered.sh

··· 5 5 6 6 test_description='Format-patch numbering options' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4022-diff-rewrite.sh

··· 2 2 3 3 test_description='rewrite diff' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff-data.sh 8 7

-1

t/t4023-diff-rename-typechange.sh

··· 2 2 3 3 test_description='typechange rename detection' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff.sh 8 7

-1

t/t4024-diff-optimize-common.sh

··· 2 2 3 3 test_description='common tail optimization' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 z=zzzzzzzz ;# 8

-1

t/t4025-hunk-header.sh

··· 2 2 3 3 test_description='diff hunk header truncation' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 N='日本語'

-1

t/t4026-color.sh

··· 5 5 6 6 test_description='Test diff/status color escape codes' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 ESC=$(printf '\033')

-1

t/t4027-diff-submodule.sh

··· 2 2 3 3 test_description='difference in submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff.sh 8 7

-1

t/t4028-format-patch-mime-headers.sh

··· 2 2 3 3 test_description='format-patch mime headers and extra headers do not conflict' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create commit with utf-8 body' '

-1

t/t4029-diff-trailing-space.sh

··· 4 4 # 5 5 test_description='diff honors config option, diff.suppressBlankEmpty' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 cat <<\EOF >expected ||

-1

t/t4030-diff-textconv.sh

··· 2 2 3 3 test_description='diff.*.textconv tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 find_diff() {

-1

t/t4031-diff-rewrite-binary.sh

··· 2 2 3 3 test_description='rewrite diff on binary file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # We must be large enough to meet the MINIMUM_BREAK_SIZE

-1

t/t4032-diff-inter-hunk-context.sh

··· 2 2 3 3 test_description='diff hunk fusing' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 f() {

-1

t/t4033-diff-patience.sh

··· 2 2 3 3 test_description='patience diff algorithm' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff-alternative.sh 8 7

-1

t/t4034-diff-words.sh

··· 2 2 3 3 test_description='word diff colors' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff.sh 8 7

-1

t/t4035-diff-quiet.sh

··· 2 2 3 3 test_description='Return value of diffs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4036-format-patch-signer-mime.sh

··· 2 2 3 3 test_description='format-patch -s should force MIME encoding as needed' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4037-diff-r-t-dirs.sh

··· 2 2 3 3 test_description='diff -r -t shows directory additions and deletions' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4038-diff-combined.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-diff.sh 11 10

-1

t/t4039-diff-assume-unchanged.sh

··· 2 2 3 3 test_description='diff with assume-unchanged entries' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # external diff has been tested in t4020-diff-external.sh

-1

t/t4040-whitespace-status.sh

··· 2 2 3 3 test_description='diff --exit-code with whitespace' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4041-diff-submodule-option.sh

··· 12 12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 # Test non-UTF-8 encoding in case iconv is available.

-1

t/t4042-diff-textconv-caching.sh

··· 2 2 3 3 test_description='test textconv caching' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >helper <<'EOF'

-1

t/t4043-diff-rename-binary.sh

··· 5 5 6 6 test_description='Move a binary file' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t4044-diff-index-unique-abbrev.sh

··· 2 2 3 3 test_description='test unique sha1 abbreviation on "index from..to" line' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4045-diff-relative.sh

··· 2 2 3 3 test_description='diff --relative tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4046-diff-unmerged.sh

··· 2 2 3 3 test_description='diff with unmerged index entries' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4047-diff-dirstat.sh

··· 2 2 3 3 test_description='diff --dirstat tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # set up two commits where the second commit has these files

-1

t/t4048-diff-combined-binary.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup binary merge conflict' '

-1

t/t4049-diff-stat-count.sh

··· 3 3 4 4 test_description='diff --stat-count' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'setup' '

-1

t/t4050-diff-histogram.sh

··· 2 2 3 3 test_description='histogram diff algorithm' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff-alternative.sh 8 7

-1

t/t4051-diff-function-context.sh

··· 2 2 3 3 test_description='diff function context' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 dir="$TEST_DIRECTORY/t4051"

-1

t/t4052-stat-output.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-terminal.sh 14 13

-1

t/t4053-diff-no-index.sh

··· 2 2 3 3 test_description='diff --no-index' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4054-diff-bogus-tree.sh

··· 2 2 3 3 test_description='test diff with a bogus tree containing the null sha1' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create bogus tree' '

-1

t/t4055-diff-context.sh

··· 5 5 6 6 test_description='diff.context configuration' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4056-diff-order.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 create_files () {

-1

t/t4057-diff-combined-paths.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # verify that diffc.expect matches output of

-1

t/t4058-diff-duplicates.sh

··· 11 11 12 12 test_description='test tree diff when trees have duplicate entries' 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 # make_tree_entry <mode> <mode> <sha1>

-1

t/t4059-diff-submodule-not-initialized.sh

··· 9 9 initialized previously but the checkout has since been removed. 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14

-1

t/t4060-diff-submodule-option-diff-format.sh

··· 10 10 This test tries to verify the sanity of --submodule=diff option of git diff. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 # Test non-UTF-8 encoding in case iconv is available.

-1

t/t4061-diff-indent.sh

··· 6 6 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 7 7 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 . "$TEST_DIRECTORY"/lib-diff.sh 12 11

-1

t/t4062-diff-pickaxe.sh

··· 5 5 6 6 test_description='Pickaxe options' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4063-diff-blobs.sh

··· 2 2 3 3 test_description='test direct comparison of blobs via git-diff' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 run_diff () {

-1

t/t4064-diff-oidfind.sh

··· 2 2 3 3 test_description='test finding specific blobs in the revision walking' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup ' '

-1

t/t4065-diff-anchored.sh

··· 2 2 3 3 test_description='anchored diff algorithm' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success '--anchored' '

-1

t/t4066-diff-emit-delay.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # This test covers a weird 3-way interaction between "--cc -p", which will run

-1

t/t4067-diff-partial-clone.sh

··· 2 2 3 3 test_description='behavior of diff when reading objects in a partial clone' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'git show batches blobs' '

-1

t/t4068-diff-symmetric-merge-base.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # build these situations:

-1

t/t4069-remerge-diff.sh

··· 2 2 3 3 test_description='remerge-diff handling' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # This test is ort-specific

-1

t/t4100-apply-stat.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 UNC='s/^\(@@ -[1-9][0-9]*\),[0-9]* \(+[1-9][0-9]*\),[0-9]* @@/\1,999 \2,999 @@/'

-1

t/t4101-apply-nonl.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # setup

-1

t/t4102-apply-rename.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # setup

-1

t/t4103-apply-binary.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'setup' '

-1

t/t4104-apply-boundary.sh

··· 5 5 6 6 test_description='git apply boundary tests' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 L="c d e f g h i j k l m n o p q r s t u v w x"

-1

t/t4105-apply-fuzz.sh

··· 3 3 test_description='apply with fuzz and offset' 4 4 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 dotest () {

-1

t/t4106-apply-stdin.sh

··· 3 3 test_description='git apply --numstat - <patch' 4 4 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success setup '

-1

t/t4107-apply-ignore-whitespace.sh

··· 5 5 6 6 test_description='git-apply --ignore-whitespace.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # This primes main.c file that indents without using HT at all.

-1

t/t4108-apply-threeway.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 print_sanitized_conflicted_diff () {

-1

t/t4109-apply-multifrag.sh

··· 7 7 test_description='git apply test patches with multiple fragments.' 8 8 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 cp "$TEST_DIRECTORY/t4109/patch1.patch" .

-1

t/t4110-apply-scan.sh

··· 8 8 9 9 ' 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success 'git apply scan' '

-1

t/t4111-apply-subdir.sh

··· 2 2 3 3 test_description='patching from inconvenient places' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4112-apply-renames.sh

··· 8 8 ' 9 9 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 # setup

-1

t/t4113-apply-ending.sh

··· 6 6 test_description='git apply trying to add an ending line. 7 7 8 8 ' 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 # setup

-1

t/t4114-apply-typechange.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup repository and commits' '

-1

t/t4115-apply-symlink.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t4116-apply-reverse.sh

··· 8 8 ' 9 9 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t4117-apply-reject.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t4118-apply-empty-context.sh

··· 8 8 ' 9 9 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t4119-apply-config.sh

··· 8 8 ' 9 9 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t4120-apply-popt.sh

··· 5 5 6 6 test_description='git apply -p handling.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4121-apply-diffs.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 echo '1

-1

t/t4122-apply-symlink-inside.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t4123-apply-shrink.sh

··· 2 2 3 3 test_description='apply a patch that is larger than the preimage' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >F <<\EOF

-1

t/t4124-apply-ws-rule.sh

··· 2 2 3 3 test_description='core.whitespace rules and git apply' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 prepare_test_file () {

-1

t/t4125-apply-ws-fuzz.sh

··· 2 2 3 3 test_description='applying patch that has broken whitespaces in context' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4126-apply-empty.sh

··· 2 2 3 3 test_description='apply empty' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4127-apply-same-fn.sh

··· 3 3 test_description='apply same filename' 4 4 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 modify () {

-1

t/t4128-apply-root.sh

··· 2 2 3 3 test_description='apply same filename' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4129-apply-samemode.sh

··· 3 3 test_description='applying patch with mode bits' 4 4 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success setup '

-1

t/t4130-apply-criss-cross-rename.sh

··· 2 2 3 3 test_description='git apply handling criss-cross rename patch.' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 create_file() {

-1

t/t4131-apply-fake-ancestor.sh

··· 5 5 6 6 test_description='git apply --build-fake-ancestor handling.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4132-apply-removal.sh

··· 5 5 test_description='git-apply notices removal patches generated by GNU diff' 6 6 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4133-apply-filenames.sh

··· 6 6 test_description='git apply filename consistency check' 7 7 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success setup '

-1

t/t4134-apply-submodule.sh

··· 6 6 test_description='git apply submodule tests' 7 7 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success setup '

-1

t/t4135-apply-weird-filenames.sh

··· 2 2 3 3 test_description='git apply with weird postimage filenames' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4136-apply-check.sh

··· 3 3 test_description='git apply should exit non-zero with unrecognized input.' 4 4 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'setup' '

-1

t/t4137-apply-submodule.sh

··· 2 2 3 3 test_description='git apply handling submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t4138-apply-ws-expansion.sh

··· 5 5 6 6 test_description='git apply test patches with whitespace expansion.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4139-apply-escape.sh

··· 2 2 3 3 test_description='paths written by git-apply cannot escape the working tree' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # tests will try to write to ../foo, and we do not

-1

t/t4140-apply-ita.sh

··· 2 2 3 3 test_description='git apply of i-t-a file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4141-apply-too-large.sh

··· 2 2 3 3 test_description='git apply with too-large patch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success EXPENSIVE 'git apply rejects patches that are too large' '

-1

t/t4150-am.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup: messages' '

-1

t/t4151-am-abort.sh

··· 2 2 3 3 test_description='am --abort' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t4152-am-subjects.sh

··· 2 2 3 3 test_description='test subject preservation with format-patch | am' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 make_patches() {

-1

t/t4153-am-resume-override-opts.sh

··· 2 2 3 3 test_description='git-am command-line options override saved options' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 format_patch () {

-1

t/t4200-rerere.sh

··· 25 25 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 26 26 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 27 27 28 28 - TEST_PASSES_SANITIZE_LEAK=true 29 28 . ./test-lib.sh 30 29 31 30 test_expect_success 'setup' '

-1

t/t4201-shortlog.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'setup' '

-1

t/t4202-log.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY/lib-gpg.sh" 11 10 . "$TEST_DIRECTORY/lib-terminal.sh"

-1

t/t4203-mailmap.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup commits and contacts file' '

-1

t/t4204-patch-id.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4205-log-pretty-formats.sh

··· 6 6 7 7 test_description='Test pretty formats' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 # Tested non-UTF-8 encoding

-1

t/t4206-log-follow-harder-copies.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh 13 12

-1

t/t4207-log-decoration-colors.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t4208-log-magic-pathspec.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t4209-log-pickaxe.sh

··· 2 2 3 3 test_description='log --grep/--author/--regexp-ignore-case/-S/-G' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_log () {

-1

t/t4210-log-i18n.sh

··· 2 2 3 3 test_description='test log with i18n features' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-gettext.sh 7 6 8 7 if ! test_have_prereq ICONV

-1

t/t4212-log-corrupt.sh

··· 2 2 3 3 test_description='git log with invalid commit headers' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4213-log-tabexpand.sh

··· 2 2 3 3 test_description='log/show --expand-tabs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 HT=" "

-1

t/t4214-log-graph-octopus.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-log-graph.sh 11 10

-1

t/t4215-log-skewed-merges.sh

··· 2 2 3 3 test_description='git log --graph of skewed merges' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-log-graph.sh 8 7

-1

t/t4216-log-bloom.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-chunk.sh 10 9

-1

t/t4217-log-limit.sh

··· 2 2 3 3 test_description='git log with filter options limiting the output' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup test' '

-1

t/t4252-am-options.sh

··· 2 2 3 3 test_description='git am with options and not losing them' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 tm="$TEST_DIRECTORY/t4252"

-1

t/t4253-am-keep-cr-dos.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 # Three patches which will be added as files with dos line ending.

-1

t/t4254-am-corrupt.sh

··· 2 2 3 3 test_description='git am with corrupt input' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if ! test_have_prereq ICONV

-1

t/t4255-am-submodule.sh

··· 2 2 3 3 test_description='git am handling submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t4256-am-format-flowed.sh

··· 2 2 3 3 test_description='test format=flowed support of git am' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t4257-am-interactive.sh

··· 2 2 3 3 test_description='am --interactive tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up patches to apply' '

-1

t/t4258-am-quoted-cr.sh

··· 2 2 3 3 test_description='test am --quoted-cr=<action>' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 DATA="$TEST_DIRECTORY/t4258"

-1

t/t4300-merge-tree.sh

··· 5 5 6 6 test_description='git merge-tree' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t4301-merge-tree-write-tree.sh

··· 2 2 3 3 test_description='git merge-tree --write-tree' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # This test is ort-specific

-1

t/t5000-tar-tree.sh

··· 25 25 ' 26 26 27 27 TEST_CREATE_REPO_NO_TEMPLATE=1 28 28 - TEST_PASSES_SANITIZE_LEAK=true 29 28 . ./test-lib.sh 30 29 31 30 SUBSTFORMAT=%H%n

-1

t/t5001-archive-attr.sh

··· 3 3 test_description='git archive attribute tests' 4 4 5 5 TEST_CREATE_REPO_NO_TEMPLATE=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 SUBSTFORMAT='%H (%h)%n'

-1

t/t5002-archive-attr-pattern.sh

··· 2 2 3 3 test_description='git archive attribute pattern tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 TEST_CREATE_REPO_NO_TEMPLATE=1 7 6 . ./test-lib.sh 8 7

-1

t/t5003-archive-zip.sh

··· 3 3 test_description='git archive --format=zip test' 4 4 5 5 TEST_CREATE_REPO_NO_TEMPLATE=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 SUBSTFORMAT=%H%n

-1

t/t5004-archive-corner-cases.sh

··· 2 2 3 3 test_description='test corner cases of git-archive' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # the 10knuls.tar file is used to test for an empty git generated tar

-1

t/t5100-mailinfo.sh

··· 5 5 6 6 test_description='git mailinfo and git mailsplit test' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 DATA="$TEST_DIRECTORY/t5100"

-1

t/t5150-request-pull.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 if ! test_have_prereq PERL

-1

t/t5200-update-server-info.sh

··· 2 2 3 3 test_description='Test git update-server-info' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' 'test_commit file'

-1

t/t5300-pack-object.sh

··· 5 5 6 6 test_description='git pack-object' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5301-sliding-window.sh

··· 5 5 6 6 test_description='mmap sliding window tests' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5302-pack-index.sh

··· 5 5 6 6 test_description='pack index with 64-bit offsets and object CRC' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5303-pack-corruption-resilience.sh

··· 5 5 6 6 test_description='resilience to pack corruptions with redundant objects' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Note: the test objects are created with knowledge of their pack encoding

-1

t/t5304-prune.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 day=$((60*60*24))

-1

t/t5305-include-tag.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 TRASH=$(pwd)

-1

t/t5306-pack-nobase.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # Create A-B chain

-1

t/t5307-pack-missing-commit.sh

··· 2 2 3 3 test_description='pack should notice missing commit objects' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t5308-pack-detect-duplicates.sh

··· 2 2 3 3 test_description='handling of duplicate objects in incoming packfiles' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-pack.sh 8 7

-1

t/t5309-pack-delta-cycles.sh

··· 2 2 3 3 test_description='test index-pack handling of delta cycles in packfiles' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-pack.sh 8 7

-1

t/t5310-pack-bitmaps.sh

··· 2 2 3 3 test_description='exercise basic bitmap functionality' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-bitmap.sh 8 7

-1

t/t5311-pack-bitmaps-shallow.sh

··· 2 2 3 3 test_description='check bitmap operation with shallow repositories' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # We want to create a situation where the shallow, grafted

-1

t/t5312-prune-corruption.sh

··· 14 14 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 15 15 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 test_expect_success 'disable reflogs' '

-1

t/t5313-pack-bounds-checks.sh

··· 2 2 3 3 test_description='bounds-checking of access to mmapped on-disk file formats' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 clear_base () {

-1

t/t5314-pack-cycle-detection.sh

··· 50 50 immediately after the lookup for "dummy". 51 51 ' 52 52 53 53 - TEST_PASSES_SANITIZE_LEAK=true 54 53 . ./test-lib.sh 55 54 56 55 # Create a pack containing the tree $1 and blob $1:file, with

-1

t/t5315-pack-objects-compression.sh

··· 2 2 3 3 test_description='pack-object compression configuration' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t5316-pack-delta-depth.sh

··· 2 2 3 3 test_description='pack-objects breaks long cross-pack delta chains' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # This mirrors a repeated push setup:

-1

t/t5317-pack-objects-filter-objects.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Test blob:none filter.

-1

t/t5318-commit-graph.sh

··· 2 2 3 3 test_description='commit graph' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-chunk.sh 8 7

-1

t/t5319-multi-pack-index.sh

··· 2 2 3 3 test_description='multi-pack-indexes' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-chunk.sh 8 7 . "$TEST_DIRECTORY"/lib-midx.sh

-1

t/t5320-delta-islands.sh

··· 2 2 3 3 test_description='exercise delta islands' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # returns true iff $1 is a delta based on $2

-1

t/t5321-pack-large-objects.sh

··· 7 7 8 8 ' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-pack.sh 13 12

-1

t/t5322-pack-objects-sparse.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup repo' '

-1

t/t5323-pack-redundant.sh

··· 34 34 Px2 | s s s x x x 35 35 ' 36 36 37 37 - TEST_PASSES_SANITIZE_LEAK=true 38 37 . ./test-lib.sh 39 38 40 39 main_repo=main.git

-1

t/t5324-split-commit-graph.sh

··· 2 2 3 3 test_description='split commit graph' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-chunk.sh 8 7

-1

t/t5325-reverse-index.sh

··· 2 2 3 3 test_description='on-disk reverse index' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # The below tests want control over the 'pack.writeReverseIndex' setting

-1

t/t5326-multi-pack-bitmaps.sh

··· 2 2 3 3 test_description='exercise basic multi-pack bitmap functionality' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "${TEST_DIRECTORY}/lib-bitmap.sh" 8 7

-1

t/t5327-multi-pack-bitmaps-rev.sh

··· 2 2 3 3 test_description='exercise basic multi-pack bitmap functionality (.rev files)' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "${TEST_DIRECTORY}/lib-bitmap.sh" 8 7

-1

t/t5328-commit-graph-64bit-time.sh

··· 2 2 3 3 test_description='commit graph with 64-bit timestamps' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if ! test_have_prereq TIME_IS_64BIT || ! test_have_prereq TIME_T_IS_64BIT

-1

t/t5329-pack-objects-cruft.sh

··· 2 2 3 3 test_description='cruft pack related pack-objects tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 objdir=.git/objects

-1

t/t5330-no-lazy-fetch-with-commit-graph.sh

··· 2 2 3 3 test_description='test for no lazy fetch with the commit-graph' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup: prepare a repository with a commit' '

-1

t/t5331-pack-objects-stdin.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 packed_objects () {

-1

t/t5332-multi-pack-reuse.sh

··· 2 2 3 3 test_description='pack-objects multi-pack reuse' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-bitmap.sh 8 7

-1

t/t5333-pseudo-merge-bitmaps.sh

··· 4 4 5 5 GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP=0 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_pseudo_merges () {

-1

t/t5334-incremental-multi-pack-index.sh

··· 2 2 3 3 test_description='incremental multi-pack-index' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-midx.sh 8 7

-1

t/t5351-unpack-large-objects.sh

··· 5 5 6 6 test_description='git unpack-objects with large objects' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 prepare_dest () {

-1

t/t5400-send-pack.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 cnt=64

-1

t/t5401-update-hooks.sh

··· 5 5 6 6 test_description='Test the update hook infrastructure.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t5402-post-merge-hook.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t5403-post-checkout-hook.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success setup '

-1

t/t5404-tracking-branches.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5405-send-pack-rewind.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t5406-remote-rejects.sh

··· 2 2 3 3 test_description='remote push rejects are reported by client' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t5407-post-rewrite-hook.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup' '

-1

t/t5408-send-pack-stdin.sh

··· 2 2 3 3 test_description='send-pack --stdin tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 create_ref () {

-1

t/t5409-colorize-remote-messages.sh

··· 2 2 3 3 test_description='remote messages are colorized on the client' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t5410-receive-pack-alternates.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5411-proc-receive-hook.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 . "$TEST_DIRECTORY"/t5411/common-functions.sh

-1

t/t5500-fetch-pack.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 # Test fetch-pack/upload-pack pair.

-1

t/t5501-fetch-push-alternates.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 count_objects () {

-1

t/t5502-quickfetch.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t5503-tagfollow.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # End state of the repository:

-1

t/t5504-fetch-receive-strict.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup and inject "corrupt or missing" object' '

-1

t/t5505-remote.sh

··· 2 2 3 3 test_description='git remote porcelain-ish' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 setup_repository () {

-1

t/t5506-remote-groups.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 mark() {

-1

t/t5507-remote-environment.sh

··· 2 2 3 3 test_description='check environment showed to remote side of transports' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'set up "remote" push situation' '

-1

t/t5509-fetch-push-namespaces.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t5510-fetch.sh

··· 5 5 6 6 ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-bundle.sh 11 10

-1

t/t5511-refspec.sh

··· 2 2 3 3 test_description='refspec parsing' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_refspec () {

-1

t/t5512-ls-remote.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 generate_references () {

-1

t/t5513-fetch-track.sh

··· 2 2 3 3 test_description='fetch follows remote-tracking branches correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t5514-fetch-multiple.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 setup_repository () {

-1

t/t5515-fetch-merge-logic.sh

··· 14 14 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 15 15 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 build_script () {

-1

t/t5516-fetch-push.sh

··· 19 19 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 20 20 21 21 TEST_CREATE_REPO_NO_TEMPLATE=1 22 22 - TEST_PASSES_SANITIZE_LEAK=true 23 22 . ./test-lib.sh 24 23 25 24 D=$(pwd)

-1

t/t5517-push-mirror.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 D=$(pwd)

-1

t/t5518-fetch-exit-status.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t5519-push-alternates.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t5520-pull.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 modify () {

-1

t/t5521-pull-options.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t5522-pull-symlink.sh

··· 2 2 3 3 test_description='pulling from symlinked subdir' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # The scenario we are building:

-1

t/t5523-push-upstream.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-terminal.sh 10 9

-1

t/t5524-pull-msg.sh

··· 2 2 3 3 test_description='git pull message generation' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 dollar='$Dollar'

-1

t/t5525-fetch-tagopt.sh

··· 2 2 3 3 test_description='tagopt variable affects "git fetch" and is overridden by commandline.' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 setup_clone () {

-1

t/t5526-fetch-submodules.sh

··· 6 6 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 7 7 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 pwd=$(pwd)

-1

t/t5527-fetch-odd-refs.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # afterwards we will have:

-1

t/t5528-push-default.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup bare remotes' '

-1

t/t5529-push-errors.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup commits' '

-1

t/t5530-upload-pack-error.sh

··· 2 2 3 3 test_description='errors in upload-pack' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 D=$(pwd)

-1

t/t5531-deep-submodule-push.sh

··· 8 8 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 9 9 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t5532-fetch-proxy.sh

··· 2 2 3 3 test_description='fetching via git:// using core.gitproxy' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup remote repo' '

-1

t/t5533-push-cas.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 setup_srcdst_basic () {

-1

t/t5534-push-signed.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-gpg.sh 11 10

-1

t/t5535-fetch-push-symref.sh

··· 2 2 3 3 test_description='avoiding conflicting update through symref aliasing' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t5536-fetch-conflicts.sh

··· 2 2 3 3 test_description='fetch handles conflicting refspecs correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 D=$(pwd)

-1

t/t5537-fetch-shallow.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 commit() {

-1

t/t5538-push-shallow.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 commit() {

-1

t/t5539-fetch-http-shallow.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-httpd.sh 11 10 start_httpd

-1

t/t5540-http-push-webdav.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 if git http-push > /dev/null 2>&1 || [ $? -eq 128 ]

-1

t/t5541-http-push-smart.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 ROOT_PATH="$PWD"

-1

t/t5542-push-http-shallow.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-httpd.sh 11 10 start_httpd

-1

t/t5543-atomic-push.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 mk_repo_pair () {

-1

t/t5544-pack-objects-hook.sh

··· 2 2 3 3 test_description='test custom script in place of pack-objects' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create some history to fetch' '

-1

t/t5545-push-options.sh

··· 8 8 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 9 9 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 mk_repo_pair () {

-1

t/t5546-receive-limits.sh

··· 2 2 3 3 test_description='check receive input limits' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Let's run tests with different unpack limits: 1 and 10000

-1

t/t5547-push-quarantine.sh

··· 2 2 3 3 test_description='check quarantine of objects during push' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create picky dest repo' '

-1

t/t5548-push-porcelain.sh

··· 4 4 # 5 5 test_description='Test git push porcelain output' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # Create commits in <repo> and assign each commit's oid to shell variables

-1

t/t5549-fetch-push-http.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-httpd.sh 11 10 start_httpd

-1

t/t5550-http-fetch-dumb.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 if test_have_prereq !REFFILES

-1

t/t5551-http-fetch-smart.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-httpd.sh 11 10 test "$HTTP_PROTO" = "HTTP/2" && enable_http2

-1

t/t5552-skipping-fetch-negotiator.sh

··· 2 2 3 3 test_description='test skipping fetch negotiator' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'fetch.negotiationalgorithm config' '

-1

t/t5553-set-upstream.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 check_config () {

-1

t/t5554-noop-fetch-negotiator.sh

··· 2 2 3 3 test_description='test noop fetch negotiator' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'noop negotiator does not emit any "have"' '

-1

t/t5555-http-smart-common.sh

··· 2 2 3 3 test_description='test functionality common to smart fetch & push' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t5557-http-get.sh

··· 2 2 3 3 test_description='test downloading a file by URL' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 7 6 . ./test-lib.sh 8 7

-1

t/t5560-http-backend-noserver.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 HTTPD_DOCUMENT_ROOT_PATH="$TRASH_DIRECTORY"

-1

t/t5561-http-backend.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-httpd.sh 10 9

-1

t/t5562-http-backend-content-length.sh

··· 2 2 3 3 test_description='test git-http-backend respects CONTENT_LENGTH' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_lazy_prereq GZIP 'gzip --version'

-1

t/t5563-simple-http-auth.sh

··· 2 2 3 3 test_description='test http auth header and credential helper interop' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-httpd.sh 8 7

-1

t/t5564-http-proxy.sh

··· 2 2 3 3 test_description="test fetching through http proxy" 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-httpd.sh 8 7

-1

t/t5570-git-daemon.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 . "$TEST_DIRECTORY"/lib-git-daemon.sh

-1

t/t5571-pre-push-hook.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t5572-pull-submodule.sh

··· 5 5 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 6 6 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-submodule-update.sh 11 10

-1

t/t5573-pull-verify-signatures.sh

··· 2 2 3 3 test_description='pull signature verification tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-gpg.sh" 8 7

-1

t/t5574-fetch-output.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'fetch with invalid output format configuration' '

-1

t/t5580-unc-paths.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 if test_have_prereq CYGWIN

-1

t/t5581-http-curl-verbose.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-httpd.sh 10 9 start_httpd

-1

t/t5582-fetch-negative-refspec.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t5583-push-branches.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 delete_refs() {

-1

t/t5600-clone-fail-cleanup.sh

··· 13 13 wrote. 14 14 ' 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./test-lib.sh 18 17 19 18 corrupt_repo () {

+15 -11

t/t5601-clone.sh

··· 544 544 test_clone_url [::1]:$repo ::1 "$repo" 545 545 ' 546 546 done 547 547 - #home directory 548 548 - test_expect_success "clone host:/~repo" ' 547 547 + 548 548 + # Home directory. All tests that use "~repo" are broken in our CI job when the 549 549 + # leak sanitizer is enabled. It seems like either a bug in the sanitizer or in 550 550 + # glibc, but when executing getpwnam(3p) with an invalid username we eventually 551 551 + # start recursing in a call to free(3p), until bust the stack and segfault. 552 552 + test_expect_success !SANITIZE_LEAK "clone host:/~repo" ' 549 553 test_clone_url host:/~repo host "~repo" 550 554 ' 551 555 552 552 - test_expect_$expectation_for_ipv6_tests "clone [::1]:/~repo" ' 556 556 + test_expect_$expectation_for_ipv6_tests !SANITIZE_LEAK "clone [::1]:/~repo" ' 553 557 test_clone_url [::1]:/~repo ::1 "~repo" 554 558 ' 555 559 ··· 569 573 test_clone_url "ssh://host.xz$tcol/home/user/repo" host.xz /home/user/repo 570 574 ' 571 575 # from home directory 572 572 - test_expect_success "clone ssh://host.xz$tcol/~repo" ' 573 573 - test_clone_url "ssh://host.xz$tcol/~repo" host.xz "~repo" 574 574 - ' 576 576 + test_expect_success !SANITIZE_LEAK "clone ssh://host.xz$tcol/~repo" ' 577 577 + test_clone_url "ssh://host.xz$tcol/~repo" host.xz "~repo" 578 578 + ' 575 579 done 576 580 577 581 # with port number ··· 580 584 ' 581 585 582 586 # from home directory with port number 583 583 - test_expect_success 'clone ssh://host.xz:22/~repo' ' 587 587 + test_expect_success !SANITIZE_LEAK 'clone ssh://host.xz:22/~repo' ' 584 588 test_clone_url "ssh://host.xz:22/~repo" "-p 22 host.xz" "~repo" 585 589 ' 586 590 ··· 597 601 for tuah in ::1 [::1] user@::1 user@[::1] [user@::1] 598 602 do 599 603 euah=$(echo $tuah | tr -d "[]") 600 600 - test_expect_success "clone ssh://$tuah/~repo" " 601 601 - test_clone_url ssh://$tuah/~repo $euah '~repo' 604 604 + test_expect_success !SANITIZE_LEAK "clone ssh://$tuah/~repo" " 605 605 + test_clone_url ssh://$tuah/~repo $euah '~repo' 602 606 " 603 607 done 604 608 ··· 615 619 for tuah in [::1] user@[::1] [user@::1] 616 620 do 617 621 euah=$(echo $tuah | tr -d "[]") 618 618 - test_expect_success "clone ssh://$tuah:22/~repo" " 619 619 - test_clone_url ssh://$tuah:22/~repo '-p 22' $euah '~repo' 622 622 + test_expect_success !SANITIZE_LEAK "clone ssh://$tuah:22/~repo" " 623 623 + test_clone_url ssh://$tuah:22/~repo '-p 22' $euah '~repo' 620 624 " 621 625 done 622 626

-1

t/t5602-clone-remote-exec.sh

··· 2 2 3 3 test_description=clone 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t5603-clone-dirname.sh

··· 2 2 3 3 test_description='check output directory names used by git-clone' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # we use a fake ssh wrapper that ignores the arguments

-1

t/t5604-clone-reference.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 base_dir=$(pwd)

-1

t/t5605-clone-local.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 repo_is_hardlinked() {

-1

t/t5606-clone-options.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t5607-clone-bundle.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t5609-clone-branch.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 check_HEAD() {

-1

t/t5610-clone-detached.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 head_is_detached() {

-1

t/t5611-clone-config.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'clone -c sets config in cloned repo' '

-1

t/t5612-clone-refspec.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t5613-info-alternate.sh

··· 5 5 6 6 test_description='test transitive info/alternate entries' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'preparing first repository' '

-1

t/t5614-clone-submodules-shallow.sh

··· 2 2 3 3 test_description='Test shallow cloning of repos with submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 pwd=$(pwd)

-1

t/t5615-alternate-env.sh

··· 2 2 3 3 test_description='handling of alternates in environment variables' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 check_obj () {

-1

t/t5616-partial-clone.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # create a normal "src" repo where we can later create new commits.

-1

t/t5617-clone-submodules-remote.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 pwd=$(pwd)

-1

t/t5618-alternate-refs.sh

··· 2 2 3 3 test_description='test handling of --alternate-refs traversal' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Avoid test_commit because we want a specific and known set of refs:

-1

t/t5619-clone-local-ambiguous-transport.sh

··· 2 2 3 3 test_description='test local clone with ambiguous transport' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-httpd.sh" 8 7

-1

t/t5700-protocol-v1.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 # Test protocol v1 with 'git://' transport

-1

t/t5701-git-serve.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'test capability advertisement' '

-1

t/t5702-protocol-v2.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # Test protocol v2 with 'git://' transport

-1

t/t5703-upload-pack-ref-in-want.sh

··· 2 2 3 3 test_description='upload-pack ref-in-want' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 get_actual_refs () {

-1

t/t5704-protocol-violations.sh

··· 5 5 communications if the other side says something unexpected. We are mostly 6 6 making sure that we do not segfault or otherwise behave badly.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'extra delim packet in v2 ls-refs args' '

-1

t/t5705-session-id-in-capabilities.sh

··· 2 2 3 3 test_description='session ID in capabilities' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 REPO="$(pwd)/repo"

-1

t/t5730-protocol-v2-bundle-uri-file.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # Test protocol v2 with 'file://' transport

-1

t/t5731-protocol-v2-bundle-uri-git.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # Test protocol v2 with 'git://' transport

-1

t/t5732-protocol-v2-bundle-uri-http.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 # Test protocol v2 with 'http://' transport

-1

t/t5750-bundle-uri-parse.sh

··· 3 3 test_description="Test bundle-uri bundle_uri_parse_line()" 4 4 5 5 TEST_NO_CREATE_REPO=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 test_expect_success 'bundle_uri_parse_line() just URIs' '

-1

t/t5801-remote-helpers.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-gpg.sh 14 13

-1

t/t5802-connect-helper.sh

··· 2 2 3 3 test_description='ext::cmd remote "connect" helper' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t5810-proto-disable-local.sh

··· 2 2 3 3 test_description='test disabling of local paths in clone/fetch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-proto-disable.sh" 8 7

-1

t/t5811-proto-disable-git.sh

··· 2 2 3 3 test_description='test disabling of git-over-tcp in clone/fetch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-proto-disable.sh" 8 7 . "$TEST_DIRECTORY/lib-git-daemon.sh"

-1

t/t5812-proto-disable-http.sh

··· 2 2 3 3 test_description='test disabling of git-over-http in clone/fetch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-proto-disable.sh" 8 7 . "$TEST_DIRECTORY/lib-httpd.sh"

-1

t/t5813-proto-disable-ssh.sh

··· 2 2 3 3 test_description='test disabling of git-over-ssh in clone/fetch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-proto-disable.sh" 8 7

-1

t/t5814-proto-disable-ext.sh

··· 2 2 3 3 test_description='test disabling of remote-helper paths in clone/fetch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY/lib-proto-disable.sh" 8 7

-1

t/t5815-submodule-protos.sh

··· 2 2 3 3 test_description='test protocol filtering with submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-proto-disable.sh 8 7

-1

t/t5900-repo-selection.sh

··· 2 2 3 3 test_description='selecting remote repo in ambiguous cases' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 reset() {

-1

t/t6000-rev-list-misc.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t6001-rev-list-graft.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t6002-rev-list-bisect.sh

··· 4 4 # 5 5 test_description='Tests git rev-list --bisect functionality' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY"/lib-t6000.sh # t6xxx specific functions 10 9

-1

t/t6003-rev-list-topo-order.sh

··· 5 5 6 6 test_description='Tests git rev-list --topo-order functionality' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-t6000.sh # t6xxx specific functions 11 10

-1

t/t6004-rev-list-path-optim.sh

··· 16 16 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 17 17 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 18 18 19 19 - TEST_PASSES_SANITIZE_LEAK=true 20 19 . ./test-lib.sh 21 20 22 21 test_expect_success setup '

-1

t/t6005-rev-list-count.sh

··· 2 2 3 3 test_description='git rev-list --max-count and --skip test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6006-rev-list-format.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-terminal.sh 14 13

-1

t/t6007-rev-list-cherry-pick-file.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # A---B---D---F

-1

t/t6008-rev-list-submodule.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success 'setup' '

-1

t/t6009-rev-list-parent.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 check_revlist () {

-1

t/t6010-merge-base.sh

··· 6 6 test_description='Merge base and parent list computation. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 M=1130000000

-1

t/t6011-rev-list-with-bad-commit.sh

··· 2 2 3 3 test_description='git rev-list should notice bad commits' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Note:

-1

t/t6012-rev-list-simplify.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 note () {

-1

t/t6013-rev-list-reverse-parents.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t6014-rev-list-all.sh

··· 2 2 3 3 test_description='--all includes detached HEADs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7

-1

t/t6016-rev-list-graph-simplify-history.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY"/lib-log-graph.sh 16 15

-1

t/t6017-rev-list-stdin.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 check () {

-1

t/t6018-rev-list-glob.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 commit () {

-1

t/t6019-rev-list-ancestry-path.sh

··· 29 29 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 30 30 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 31 31 32 32 - TEST_PASSES_SANITIZE_LEAK=true 33 32 . ./test-lib.sh 34 33 35 34 test_merge () {

-1

t/t6020-bundle-misc.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-bundle.sh 14 13 . "$TEST_DIRECTORY"/lib-terminal.sh

-1

t/t6021-rev-list-exclude-hidden.sh

··· 2 2 3 3 test_description='git rev-list --exclude-hidden test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6022-rev-list-missing.sh

··· 2 2 3 3 test_description='handling of missing objects in rev-list' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # We setup the repository with two commits, this way HEAD is always

-1

t/t6040-tracking-info.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 advance () {

-1

t/t6041-bisect-submodule.sh

··· 2 2 3 3 test_description='bisect can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t6050-replace.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY/lib-gpg.sh" 13 12

-1

t/t6060-merge-index.sh

··· 2 2 3 3 test_description='basic git merge-index / git-merge-one-file tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup diverging branches' '

-1

t/t6100-rev-list-in-order.sh

··· 2 2 3 3 test_description='rev-list testing in-commit-order' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup a commit history with trees, blobs' '

-1

t/t6101-rev-parse-parents.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 TEST_CREATE_REPO_NO_TEMPLATE=1 13 12 . ./test-lib.sh 14 13

-1

t/t6102-rev-list-unexpected-objects.sh

··· 2 2 3 3 test_description='git rev-list should handle unexpected object types' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup well-formed objects' '

-1

t/t6110-rev-list-sparse.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t6111-rev-list-treesame.sh

··· 16 16 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 17 17 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 18 18 19 19 - TEST_PASSES_SANITIZE_LEAK=true 20 19 . ./test-lib.sh 21 20 22 21 note () {

-1

t/t6112-rev-list-filters-objects.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Test the blob:none filter.

-1

t/t6113-rev-list-bitmap-filters.sh

··· 2 2 3 3 test_description='rev-list combining bitmaps and filters' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-bitmap.sh 8 7

-1

t/t6114-keep-packs.sh

··· 2 2 3 3 test_description='rev-list with .keep packs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6115-rev-list-du.sh

··· 2 2 3 3 test_description='basic tests of rev-list --disk-usage' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # we want a mix of reachable and unreachable, as well as

-1

t/t6120-describe.sh

··· 14 14 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 15 15 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 check_describe () {

-1

t/t6130-pathspec-noglob.sh

··· 2 2 3 3 test_description='test globbing (and noglob) of pathspec limiting' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create commits with glob characters' '

-1

t/t6131-pathspec-icase.sh

··· 2 2 3 3 test_description='test case insensitive pathspec limiting' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 if test_have_prereq CASE_INSENSITIVE_FS

-1

t/t6132-pathspec-exclude.sh

··· 2 2 3 3 test_description='test case exclude pathspec' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6133-pathspec-rev-dwim.sh

··· 2 2 3 3 test_description='test dwim of revs versus pathspecs in revision parser' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6134-pathspec-in-submodule.sh

··· 2 2 3 3 test_description='test case exclude pathspec' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup a submodule' '

-1

t/t6135-pathspec-with-attrs.sh

··· 2 2 3 3 test_description='test labels in pathspecs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup a tree' '

-1

t/t6136-pathspec-in-bare.sh

··· 2 2 3 3 test_description='diagnosing out-of-scope pathspec' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup a bare and non-bare repository' '

-1

t/t6200-fmt-merge-msg.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY/lib-gpg.sh" 14 13

-1

t/t6300-for-each-ref.sh

··· 5 5 6 6 test_description='for-each-ref test' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 GNUPGHOME_NOT_USED=$GNUPGHOME 11 10 . "$TEST_DIRECTORY"/lib-gpg.sh

-1

t/t6301-for-each-ref-errors.sh

··· 2 2 3 3 test_description='for-each-ref errors for broken refs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 ZEROS=$ZERO_OID

-1

t/t6302-for-each-ref-filter.sh

··· 2 2 3 3 test_description='test for-each-refs usage of ref-filter APIs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-gpg.sh 8 7

-1

t/t6400-merge-df.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'prepare repository' '

-1

t/t6401-merge-criss-cross.sh

··· 9 9 10 10 test_description='Test criss-cross merge' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'prepare repository' '

-1

t/t6402-merge-rename.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 modify () {

-1

t/t6403-merge-file.sh

··· 2 2 3 3 test_description='RCS merge replacement: merge-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t6404-recursive-merge.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # This scenario is based on a real-world repository of Shawn Pearce.

-1

t/t6405-merge-symlinks.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 test_expect_success 'setup' '

-1

t/t6406-merge-attr.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 test_expect_success setup '

-1

t/t6407-merge-binary.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t6408-merge-up-to-date.sh

··· 2 2 3 3 test_description='merge fast-forward and up to date' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t6409-merge-subtree.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t6411-merge-filemode.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'set up mode change in one branch' '

-1

t/t6412-merge-large-rename.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 count() {

-1

t/t6413-merge-crlf.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 test_expect_success setup '

-1

t/t6414-merge-rename-nocruft.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t6415-merge-dir-to-symlink.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'create a commit where dir a/b changed to symlink' '

-1

t/t6416-recursive-corner-cases.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-merge.sh 11 10

-1

t/t6417-merge-ours-theirs.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success setup '

-1

t/t6418-merge-text-auto.sh

··· 15 15 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 16 16 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 17 17 18 18 - TEST_PASSES_SANITIZE_LEAK=true 19 18 . ./test-lib.sh 20 19 21 20 test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b

-1

t/t6421-merge-partial-clone.sh

··· 26 26 # underscore notation is to differentiate different 27 27 # files that might be renamed into each other's paths.) 28 28 29 29 - TEST_PASSES_SANITIZE_LEAK=true 30 29 . ./test-lib.sh 31 30 . "$TEST_DIRECTORY"/lib-merge.sh 32 31

-1

t/t6422-merge-rename-corner-cases.sh

··· 6 6 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 7 7 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 . "$TEST_DIRECTORY"/lib-merge.sh 12 11

-1

t/t6423-merge-rename-directories.sh

··· 25 25 # underscore notation is to differentiate different 26 26 # files that might be renamed into each other's paths.) 27 27 28 28 - TEST_PASSES_SANITIZE_LEAK=true 29 28 . ./test-lib.sh 30 29 . "$TEST_DIRECTORY"/lib-merge.sh 31 30

-1

t/t6424-merge-unrelated-index-changes.sh

··· 2 2 3 3 test_description="merges with unrelated index changes" 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Testcase for some simple merges

-1

t/t6425-merge-rename-delete.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'rename/delete' '

-1

t/t6426-merge-skip-unneeded-updates.sh

··· 22 22 # underscore notation is to differentiate different 23 23 # files that might be renamed into each other's paths.) 24 24 25 25 - TEST_PASSES_SANITIZE_LEAK=true 26 25 . ./test-lib.sh 27 26 . "$TEST_DIRECTORY"/lib-merge.sh 28 27

-1

t/t6427-diff3-conflict-markers.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # Setup:

-1

t/t6428-merge-conflicts-sparse.sh

··· 22 22 # underscore notation is to differentiate different 23 23 # files that might be renamed into each other's paths.) 24 24 25 25 - TEST_PASSES_SANITIZE_LEAK=true 26 25 . ./test-lib.sh 27 26 . "$TEST_DIRECTORY"/lib-merge.sh 28 27

-1

t/t6429-merge-sequence-rename-caching.sh

··· 2 2 3 3 test_description="remember regular & dir renames in sequence of merges" 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 #

-1

t/t6430-merge-recursive.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-merge.sh 11 10

-1

t/t6431-merge-criscross.sh

··· 2 2 3 3 test_description='merge-recursive backend test' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # A <- create some files

-1

t/t6432-merge-recursive-space-options.sh

··· 14 14 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 15 15 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b

-1

t/t6433-merge-toplevel.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 t3033_reset () {

-1

t/t6434-merge-recursive-rename-options.sh

··· 29 29 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 30 30 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 31 31 32 32 - TEST_PASSES_SANITIZE_LEAK=true 33 32 . ./test-lib.sh 34 33 35 34 get_expected_stages () {

-1

t/t6435-merge-sparse.sh

··· 3 3 test_description='merge with sparse files' 4 4 5 5 TEST_CREATE_REPO_NO_TEMPLATE=1 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 9 8 # test_file $filename $content

-1

t/t6436-merge-overwrite.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup' '

-1

t/t6437-submodule-merge.sh

··· 8 8 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 9 9 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 . "$TEST_DIRECTORY"/lib-merge.sh 14 13

-1

t/t6438-submodule-directory-file-conflicts.sh

··· 2 2 3 3 test_description='merge can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t6439-merge-co-error-msgs.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t6500-gc.sh

··· 3 3 test_description='basic git gc tests 4 4 ' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 . "$TEST_DIRECTORY"/lib-terminal.sh 9 8

-1

t/t6501-freshen-objects.sh

··· 28 28 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 29 29 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 30 30 31 31 - TEST_PASSES_SANITIZE_LEAK=true 32 31 . ./test-lib.sh 33 32 34 33 # We care about reachability, so we do not want to use

-1

t/t6600-test-reach.sh

··· 2 2 3 3 test_description='basic commit reachability tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Construct a grid-like commit graph with points (x,y)

-1

t/t6700-tree-depth.sh

··· 2 2 3 3 test_description='handling of deep trees in various commands' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # We'll test against two depths here: a small one that will let us check the

-1

t/t7001-mv.sh

··· 2 2 3 3 test_description='git mv in subdirs' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-diff-data.sh 8 7

-1

t/t7002-mv-sparse-checkout.sh

··· 2 2 3 3 test_description='git mv in sparse working trees' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 setup_sparse_checkout () {

-1

t/t7003-filter-branch.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY/lib-gpg.sh" 10 9

-1

t/t7004-tag.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 . "$TEST_DIRECTORY"/lib-gpg.sh 16 15 . "$TEST_DIRECTORY"/lib-terminal.sh

-1

t/t7005-editor.sh

··· 2 2 3 3 test_description='GIT_EDITOR, core.editor, and stuff' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 unset EDITOR VISUAL GIT_EDITOR

-1

t/t7006-pager.sh

··· 2 2 3 3 test_description='Test automatic use of a pager.' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-pager.sh 8 7 . "$TEST_DIRECTORY"/lib-terminal.sh

-1

t/t7007-show.sh

··· 2 2 3 3 test_description='git show' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t7008-filter-branch-null-sha1.sh

··· 2 2 3 3 test_description='filter-branch removal of trees with null sha1' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup: base commits' '

-1

t/t7010-setup.sh

··· 2 2 3 3 test_description='setup taking and sanitizing funny paths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t7011-skip-worktree-reading.sh

··· 5 5 6 6 test_description='skip-worktree bit test' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 cat >expect.full <<EOF

-1

t/t7012-skip-worktree-writing.sh

··· 5 5 6 6 test_description='test worktree writing operations when skip-worktree is used' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t7030-verify-tag.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY/lib-gpg.sh" 10 9

-1

t/t7031-verify-tag-signed-ssh.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY/lib-gpg.sh" 10 9

-1

t/t7060-wtstatus.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t7061-wtstatus-ignore.sh

··· 2 2 3 3 test_description='git-status ignored files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >expected <<\EOF

-1

t/t7062-wtstatus-ignorecase.sh

··· 2 2 3 3 test_description='git-status with core.ignorecase=true' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'status with hash collisions' '

-1

t/t7063-status-untracked-cache.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # On some filesystems (e.g. FreeBSD's ext2 and ufs) directory mtime

-1

t/t7064-wtstatus-pv2.sh

··· 4 4 5 5 This test exercises porcelain V2 output for git status.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9

-1

t/t7101-reset-empty-subdirs.sh

··· 5 5 6 6 test_description='git reset should cull empty subdirs' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-diff-data.sh 11 10

-1

t/t7102-reset.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 if test_have_prereq ICONV

-1

t/t7103-reset-bare.sh

··· 2 2 3 3 test_description='git reset in a bare repository' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup non-bare' '

-1

t/t7104-reset-hard.sh

··· 2 2 3 3 test_description='reset --hard unmerged' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t7105-reset-patch.sh

··· 2 2 3 3 test_description='git reset --patch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-patch-mode.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7106-reset-unborn-branch.sh

··· 2 2 3 3 test_description='git reset should work on unborn branch' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7107-reset-pathspec-file.sh

··· 2 2 3 3 test_description='reset --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t7110-reset-merge.sh

··· 5 5 6 6 test_description='Tests for "git reset" with "--merge" and "--keep" options' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t7111-reset-table.sh

··· 5 5 6 6 test_description='Tests to check that "reset" options follow a known table' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10

-1

t/t7112-reset-submodule.sh

··· 2 2 3 3 test_description='reset can handle submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-submodule-update.sh 8 7

-1

t/t7113-post-index-change-hook.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'setup' '

-1

t/t7201-co.sh

··· 23 23 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 24 24 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 25 25 26 26 - TEST_PASSES_SANITIZE_LEAK=true 27 26 . ./test-lib.sh 28 27 29 28 test_tick

-1

t/t7300-clean.sh

··· 5 5 6 6 test_description='git clean basic tests' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 git config clean.requireForce no

-1

t/t7301-clean-interactive.sh

··· 2 2 3 3 test_description='git clean -i basic tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-terminal.sh 8 7

-1

t/t7400-submodule-basic.sh

··· 12 12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 test_expect_success 'setup - enable local submodules' '

-1

t/t7401-submodule-summary.sh

··· 17 17 # various reasons, one of them being that there are lots of commands taking place 18 18 # outside of 'test_expect_success' block, which is no longer in good-style. 19 19 20 20 - TEST_PASSES_SANITIZE_LEAK=true 21 20 . ./test-lib.sh 22 21 23 22 add_file () {

-1

t/t7402-submodule-rebase.sh

··· 5 5 6 6 test_description='Test rebasing, stashing, etc. with submodules' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t7403-submodule-sync.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 test_expect_success setup '

-1

t/t7406-submodule-update.sh

··· 12 12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17

-1

t/t7407-submodule-foreach.sh

··· 12 12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17

-1

t/t7408-submodule-reference.sh

··· 5 5 6 6 test_description='test clone --reference' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 base_dir=$(pwd)

-1

t/t7409-submodule-detached-work-tree.sh

··· 13 13 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 14 14 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./test-lib.sh 18 17 19 18 test_expect_success 'setup' '

-1

t/t7411-submodule-config.sh

··· 10 10 ' 11 11 12 12 TEST_NO_CREATE_REPO=1 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 test_expect_success 'setup' '

-1

t/t7412-submodule-absorbgitdirs.sh

··· 6 6 directory into the superproject. 7 7 ' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'setup a real submodule' '

-1

t/t7413-submodule-is-active.sh

··· 9 9 which is also indirectly tested elsewhere. 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'setup' '

-1

t/t7414-submodule-mistakes.sh

··· 2 2 3 3 test_description='handling of common mistakes people may make with submodules' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'create embedded repository' '

-1

t/t7416-submodule-dash-url.sh

··· 2 2 3 3 test_description='check handling of disallowed .gitmodule urls' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7417-submodule-path-url.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t7418-submodule-sparse-gitmodules.sh

··· 15 15 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1 16 16 export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB 17 17 18 18 - TEST_PASSES_SANITIZE_LEAK=true 19 18 . ./test-lib.sh 20 19 21 20 test_expect_success 'setup' '

-1

t/t7419-submodule-set-branch.sh

··· 9 9 as expected. 10 10 ' 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 TEST_NO_CREATE_REPO=1 14 13 15 14 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main

-1

t/t7420-submodule-set-url.sh

··· 10 10 ' 11 11 12 12 TEST_NO_CREATE_REPO=1 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 test_expect_success 'setup' '

-1

t/t7421-submodule-summary-add.sh

··· 10 10 `git add` as done in t7401. 11 11 ' 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 test_expect_success 'setup' '

-1

t/t7422-submodule-output.sh

··· 2 2 3 3 test_description='submodule --cached, --quiet etc. output' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "$TEST_DIRECTORY"/lib-t3100.sh 8 7

-1

t/t7423-submodule-symlinks.sh

··· 2 2 3 3 test_description='check that submodule operations do not follow symlinks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'prepare' '

-1

t/t7424-submodule-mixed-ref-formats.sh

··· 2 2 3 3 test_description='submodules handle mixed ref storage formats' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_ref_format () {

-1

t/t7450-bad-git-dotfiles.sh

··· 13 13 - symlinked .gitmodules, etc 14 14 ' 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./test-lib.sh 18 17 . "$TEST_DIRECTORY"/lib-pack.sh 19 18

-1

t/t7500-commit-template-squash-signoff.sh

··· 7 7 8 8 Tests for template, signoff, squash and -F functions.' 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t7501-commit-basic-functionality.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 . "$TEST_DIRECTORY/lib-diff.sh" 15 14

-1

t/t7502-commit-porcelain.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 commit_msg_is () {

-1

t/t7503-pre-commit-and-pre-merge-commit-hooks.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'root commit' '

-1

t/t7504-commit-msg-hook.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'with no hook' '

-1

t/t7505-prepare-commit-msg-hook.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success 'set up commits for rebasing' '

-1

t/t7506-status-submodule.sh

··· 2 2 3 3 test_description='git status for submodule' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_create_repo_with_commit () {

-1

t/t7507-commit-verbose.sh

··· 2 2 3 3 test_description='verbose commit template' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 write_script "check-for-diff" <<\EOF &&

-1

t/t7508-status.sh

··· 5 5 6 6 test_description='git status' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-terminal.sh 11 10

-1

t/t7509-commit-authorship.sh

··· 5 5 6 6 test_description='commit tests of various authorhip options. ' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 author_header () {

-1

t/t7510-signed-commit.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 GNUPGHOME_NOT_USED=$GNUPGHOME 10 9 . "$TEST_DIRECTORY/lib-gpg.sh"

-1

t/t7511-status-index.sh

··· 2 2 3 3 test_description='git status with certain file name lengths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 files="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z"

-1

t/t7512-status-help.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 . "$TEST_DIRECTORY"/lib-rebase.sh

-1

t/t7513-interpret-trailers.sh

··· 5 5 6 6 test_description='git interpret-trailers' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 # When we want one trailing space at the end of each line, let's use sed

-1

t/t7514-commit-patch.sh

··· 2 2 3 3 test_description='hunk edit with "commit -p -m"' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup (initial)' '

-1

t/t7515-status-symlinks.sh

··· 2 2 3 3 test_description='git status and symlinks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7516-commit-races.sh

··· 2 2 3 3 test_description='git commit races' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'race to create orphan commit' '

-1

t/t7517-per-repo-email.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_expect_success 'setup a likely user.useConfigOnly use case' '

-1

t/t7518-ident-corner-cases.sh

··· 2 2 3 3 test_description='corner cases in ident strings' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # confirm that we do not segfault _and_ that we do not say "(null)", as

-1

t/t7519-status-fsmonitor.sh

··· 2 2 3 3 test_description='git status with file system watcher' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Note, after "git reset --hard HEAD" no extensions exist other than 'TREE'

-1

t/t7520-ignored-hook-warning.sh

··· 2 2 3 3 test_description='ignored hook warning' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success setup '

-1

t/t7521-ignored-mode.sh

··· 2 2 3 3 test_description='git status ignored modes' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup initial commit and ignore file' '

-1

t/t7524-commit-summary.sh

··· 2 2 3 3 test_description='git commit summary' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7525-status-rename.sh

··· 2 2 3 3 test_description='git status rename detection options' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t7526-commit-pathspec-file.sh

··· 2 2 3 3 test_description='commit --pathspec-from-file' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_tick

-1

t/t7528-signed-commit-ssh.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 GNUPGHOME_NOT_USED=$GNUPGHOME 10 9 . "$TEST_DIRECTORY/lib-gpg.sh"

-1

t/t7600-merge.sh

··· 29 29 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 30 30 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 31 31 32 32 - TEST_PASSES_SANITIZE_LEAK=true 33 32 . ./test-lib.sh 34 33 . "$TEST_DIRECTORY"/lib-gpg.sh 35 34

-1

t/t7601-merge-pull-config.sh

··· 4 4 5 5 Testing pull.* configuration parsing and other things.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t7602-merge-octopus-many.sh

··· 4 4 5 5 Testing octopus merge with more than 25 refs.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t7603-merge-reduce-heads.sh

··· 4 4 5 5 Testing octopus merge when reducing parents to independent branches.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # 0 - 1

-1

t/t7604-merge-custom-message.sh

··· 4 4 5 5 Testing merge when using a custom message for the merge commit.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 create_merge_msgs() {

-1

t/t7605-merge-resolve.sh

··· 4 4 5 5 Testing the resolve strategy.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t7606-merge-custom.sh

··· 14 14 * (tag: c0) c0 15 15 " 16 16 17 17 - TEST_PASSES_SANITIZE_LEAK=true 18 17 . ./test-lib.sh 19 18 20 19 test_expect_success 'set up custom strategy' '

-1

t/t7607-merge-state.sh

··· 4 4 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'Ensure we restore original state if no merge strategy handles it' '

-1

t/t7608-merge-messages.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 check_oneline() {

-1

t/t7609-mergetool--lib.sh

··· 4 4 5 5 Testing basic merge tools options' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'mergetool --tool=vimdiff creates the expected layout' '

-1

t/t7610-mergetool.sh

··· 10 10 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 11 11 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 12 12 13 13 - TEST_PASSES_SANITIZE_LEAK=true 14 13 . ./test-lib.sh 15 14 16 15 # All the mergetool test work by checking out a temporary branch based

-1

t/t7611-merge-abort.sh

··· 25 25 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 26 26 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 27 27 28 28 - TEST_PASSES_SANITIZE_LEAK=true 29 28 . ./test-lib.sh 30 29 31 30 test_expect_success 'setup' '

-1

t/t7612-merge-verify-signatures.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 . "$TEST_DIRECTORY/lib-gpg.sh" 10 9

-1

t/t7614-merge-signoff.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 # Setup test files

-1

t/t7615-diff-algo-with-mergy-operations.sh

··· 4 4 5 5 Testing the influence of the diff algorithm on the merge output.' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup' '

-1

t/t7700-repack.sh

··· 2 2 3 3 test_description='git repack works correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "${TEST_DIRECTORY}/lib-bitmap.sh" 8 7 . "${TEST_DIRECTORY}/lib-midx.sh"

-1

t/t7701-repack-unpack-unreachable.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 fsha1=

-1

t/t7702-repack-cyclic-alternate.sh

··· 5 5 6 6 test_description='repack involving cyclic alternate' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_expect_success setup '

-1

t/t7703-repack-geometric.sh

··· 2 2 3 3 test_description='git repack --geometric works correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 GIT_TEST_MULTI_PACK_INDEX=0

-1

t/t7704-repack-cruft.sh

··· 2 2 3 3 test_description='git repack works correctly' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 objdir=.git/objects

-1

t/t7800-difftool.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 difftool_test_setup ()

-1

t/t7810-grep.sh

··· 9 9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 10 10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 11 11 12 12 - TEST_PASSES_SANITIZE_LEAK=true 13 12 . ./test-lib.sh 14 13 15 14 test_invalid_grep_expression() {

-1

t/t7811-grep-open.sh

··· 3 3 test_description='git grep --open-files-in-pager 4 4 ' 5 5 6 6 - TEST_PASSES_SANITIZE_LEAK=true 7 6 . ./test-lib.sh 8 7 . "$TEST_DIRECTORY"/lib-pager.sh 9 8 unset PAGER GIT_PAGER

-1

t/t7812-grep-icase-non-ascii.sh

··· 2 2 3 3 test_description='grep icase on non-English locales' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-gettext.sh 7 6 8 7 doalarm () {

-1

t/t7813-grep-icase-iso.sh

··· 2 2 3 3 test_description='grep icase on non-English locales' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-gettext.sh 7 6 8 7 test_expect_success GETTEXT_ISO_LOCALE 'setup' '

-1

t/t7814-grep-recurse-submodules.sh

··· 7 7 ' 8 8 9 9 TEST_CREATE_REPO_NO_TEMPLATE=1 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1

-1

t/t7815-grep-binary.sh

··· 2 2 3 3 test_description='git grep in binary files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' "

-1

t/t7816-grep-binary-pattern.sh

··· 2 2 3 3 test_description='git grep with a binary pattern files' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-gettext.sh 7 6 8 7 nul_match_internal () {

-1

t/t7817-grep-sparse-checkout.sh

··· 33 33 But note that sub2 should have the SKIP_WORKTREE bit set. 34 34 ' 35 35 36 36 - TEST_PASSES_SANITIZE_LEAK=true 37 36 . ./test-lib.sh 38 37 39 38 test_expect_success 'setup' '

-1

t/t7900-maintenance.sh

··· 2 2 3 3 test_description='git maintenance builtin' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 GIT_TEST_COMMIT_GRAPH=0

-1

t/t8001-annotate.sh

··· 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 TEST_CREATE_REPO_NO_TEMPLATE=1 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 PROG='git annotate'

-1

t/t8002-blame.sh

··· 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 TEST_CREATE_REPO_NO_TEMPLATE=1 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 PROG='git blame -c'

-1

t/t8003-blame-corner-cases.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 pick_fc='s/^[0-9a-f^]* *\([^ ]*\) *(\([^ ]*\) .*/\1-\2/'

-1

t/t8004-blame-with-conflicts.sh

··· 6 6 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 7 7 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./test-lib.sh 11 10 12 11 test_expect_success 'setup first case' '

+1

t/t8005-blame-i18n.sh

··· 1 1 #!/bin/sh 2 2 3 3 test_description='git blame encoding conversion' 4 4 + 4 5 . ./test-lib.sh 5 6 6 7 if ! test_have_prereq ICONV

-1

t/t8006-blame-textconv.sh

··· 2 2 3 3 test_description='git blame textconv support' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 find_blame() {

-1

t/t8007-cat-file-textconv.sh

··· 2 2 3 3 test_description='git cat-file textconv support' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 cat >helper <<'EOF'

-1

t/t8008-blame-formats.sh

··· 2 2 3 3 test_description='blame output in various formats on a simple case' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t8009-blame-vs-topicbranches.sh

··· 2 2 3 3 test_description='blaming through history with topic branches' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Creates the history shown below. '*'s mark the first parent in the merges.

-1

t/t8010-cat-file-filters.sh

··· 2 2 3 3 test_description='git cat-file filters support' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup ' '

-1

t/t8011-blame-split-file.sh

··· 11 11 behaves now, but it is not a property we want to make sure is retained. 12 12 ' 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 # help avoid typing and reading long strings of similar lines

-1

t/t8012-blame-colors.sh

··· 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 TEST_CREATE_REPO_NO_TEMPLATE=1 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 PROG='git blame -c'

-1

t/t8013-blame-ignore-revs.sh

··· 2 2 3 3 test_description='ignore revisions when blaming' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 # Creates:

-1

t/t8014-blame-ignore-fuzzy.sh

··· 2 2 3 3 test_description='git blame ignore fuzzy heuristic' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 pick_author='s/^[0-9a-f^]* *(\([^ ]*\) .*/\1/'

-1

t/t9001-send-email.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 # May be altered later in the test

-1

t/t9002-column.sh

··· 1 1 #!/bin/sh 2 2 3 3 test_description='git column' 4 4 - TEST_PASSES_SANITIZE_LEAK=true 5 4 . ./test-lib.sh 6 5 7 6 test_expect_success 'setup' '

-1

t/t9003-help-autocorrect.sh

··· 2 2 3 3 test_description='help.autocorrect finding a match' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup' '

-1

t/t9200-git-cvsexportcommit.sh

··· 4 4 # 5 5 test_description='Test export of commits to CVS' 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 if ! test_have_prereq PERL; then

-1

t/t9210-scalar.sh

··· 2 2 3 3 test_description='test the `scalar` command' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt,launchctl:true,schtasks:true"

-1

t/t9211-scalar-clone.sh

··· 2 2 3 3 test_description='test the `scalar clone` subcommand' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 . "${TEST_DIRECTORY}/lib-terminal.sh" 8 7

-1

t/t9300-fast-import.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 . "$TEST_DIRECTORY"/lib-diff.sh ;# test-lib chdir's into trash 13 12

-1

t/t9301-fast-import-notes.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12

-1

t/t9302-fast-import-unpack-limit.sh

··· 1 1 #!/bin/sh 2 2 test_description='test git fast-import unpack limit' 3 3 4 4 - TEST_PASSES_SANITIZE_LEAK=true 5 4 . ./test-lib.sh 6 5 7 6 test_expect_success 'create loose objects on import' '

-1

t/t9303-fast-import-compression.sh

··· 2 2 3 3 test_description='compression setting of fast-import utility' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 import_large () {

-1

t/t9304-fast-import-marks.sh

··· 2 2 3 3 test_description='test exotic situations with marks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'setup dump of basic history' '

-1

t/t9350-fast-export.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./test-lib.sh 12 11 13 12 test_expect_success 'setup' '

-1

t/t9351-fast-export-anonymize.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./test-lib.sh 9 8 10 9 test_expect_success 'setup simple repo' '

-1

t/t9400-git-cvsserver-server.sh

··· 11 11 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 12 12 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 13 13 14 14 - TEST_PASSES_SANITIZE_LEAK=true 15 14 . ./test-lib.sh 16 15 17 16 if ! test_have_prereq PERL; then

-1

t/t9401-git-cvsserver-crlf.sh

··· 12 12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 13 13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 14 14 15 15 - TEST_PASSES_SANITIZE_LEAK=true 16 15 . ./test-lib.sh 17 16 18 17 marked_as () {

-1

t/t9402-git-cvsserver-refs.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./test-lib.sh 13 12 14 13 #########

-1

t/t9500-gitweb-standalone-no-errors.sh

··· 13 13 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 14 14 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./lib-gitweb.sh 18 17 19 18 # ----------------------------------------------------------------------

-1

t/t9501-gitweb-standalone-http-status.sh

··· 13 13 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 14 14 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./lib-gitweb.sh 18 17 19 18 #

-1

t/t9502-gitweb-standalone-parse-output.sh

··· 13 13 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 14 14 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./lib-gitweb.sh 18 17 19 18 # ----------------------------------------------------------------------

-1

t/t9600-cvsimport.sh

··· 4 4 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 5 5 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 6 6 7 7 - TEST_PASSES_SANITIZE_LEAK=true 8 7 . ./lib-cvs.sh 9 8 10 9 if ! test_have_prereq NOT_ROOT; then

-1

t/t9601-cvsimport-vendor-branch.sh

··· 35 35 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 36 36 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 37 37 38 38 - TEST_PASSES_SANITIZE_LEAK=true 39 38 . ./lib-cvs.sh 40 39 41 40 setup_cvs_test_repository t9601

-1

t/t9602-cvsimport-branches-tags.sh

··· 7 7 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 8 8 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 9 9 10 10 - TEST_PASSES_SANITIZE_LEAK=true 11 10 . ./lib-cvs.sh 12 11 13 12 setup_cvs_test_repository t9602

-1

t/t9603-cvsimport-patchsets.sh

··· 13 13 14 14 test_description='git cvsimport testing for correct patchset estimation' 15 15 16 16 - TEST_PASSES_SANITIZE_LEAK=true 17 16 . ./lib-cvs.sh 18 17 19 18 setup_cvs_test_repository t9603

-1

t/t9604-cvsimport-timestamps.sh

··· 2 2 3 3 test_description='git cvsimport timestamps' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-cvs.sh 7 6 8 7 test_lazy_prereq POSIX_TIMEZONE '

-1

t/t9700-perl-git.sh

··· 5 5 6 6 test_description='perl interface (Git.pm)' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 . "$TEST_DIRECTORY"/lib-perl.sh 11 10

-1

t/t9800-git-p4-basic.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-git-p4.sh 10 9 11 10 test_expect_success 'start p4d' '

-1

t/t9801-git-p4-branch.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-git-p4.sh 10 9 11 10 test_expect_success 'start p4d' '

-1

t/t9802-git-p4-filetype.sh

··· 2 2 3 3 test_description='git p4 filetype tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9803-git-p4-shell-metachars.sh

··· 2 2 3 3 test_description='git p4 transparency to shell metachars in filenames' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9804-git-p4-label.sh

··· 2 2 3 3 test_description='git p4 label tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9805-git-p4-skip-submit-edit.sh

··· 2 2 3 3 test_description='git p4 skipSubmitEdit config variables' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9806-git-p4-options.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-git-p4.sh 10 9 11 10 test_expect_success 'start p4d' '

-1

t/t9808-git-p4-chdir.sh

··· 2 2 3 3 test_description='git p4 relative chdir' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9809-git-p4-client-view.sh

··· 2 2 3 3 test_description='git p4 client view' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9810-git-p4-rcs.sh

··· 2 2 3 3 test_description='git p4 rcs keywords' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 CP1252="\223\224"

-1

t/t9811-git-p4-label-import.sh

··· 5 5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 6 6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./lib-git-p4.sh 10 9 11 10 test_expect_success 'start p4d' '

-1

t/t9812-git-p4-wildcards.sh

··· 2 2 3 3 test_description='git p4 wildcards' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9813-git-p4-preserve-users.sh

··· 2 2 3 3 test_description='git p4 preserve users' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9814-git-p4-rename.sh

··· 2 2 3 3 test_description='git p4 rename' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9815-git-p4-submit-fail.sh

··· 2 2 3 3 test_description='git p4 submit failure handling' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9816-git-p4-locked.sh

··· 2 2 3 3 test_description='git p4 locked file behavior' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9817-git-p4-exclude.sh

··· 2 2 3 3 test_description='git p4 tests for excluded paths during clone and sync' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9818-git-p4-block.sh

··· 2 2 3 3 test_description='git p4 fetching changes in multiple blocks' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9819-git-p4-case-folding.sh

··· 2 2 3 3 test_description='interaction with P4 case-folding' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 if test_have_prereq CASE_INSENSITIVE_FS

-1

t/t9820-git-p4-editor-handling.sh

··· 2 2 3 3 test_description='git p4 handling of EDITOR' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9821-git-p4-path-variations.sh

··· 2 2 3 3 test_description='Clone repositories with path case variations' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d with case folding enabled' '

-1

t/t9822-git-p4-path-encoding.sh

··· 2 2 3 3 test_description='Clone repositories with non ASCII paths' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 UTF8_ESCAPED="a-\303\244_o-\303\266_u-\303\274.txt"

-1

t/t9823-git-p4-mock-lfs.sh

··· 2 2 3 3 test_description='Clone repositories and store files in Mock LFS' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_file_is_not_in_mock_lfs () {

-1

t/t9825-git-p4-handle-utf16-without-bom.sh

··· 2 2 3 3 test_description='git p4 handling of UTF-16 files without BOM' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 UTF16="\227\000\227\000"

-1

t/t9826-git-p4-keep-empty-commits.sh

··· 2 2 3 3 test_description='Clone repositories and keep empty commits' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9827-git-p4-change-filetype.sh

··· 2 2 3 3 test_description='git p4 support for file type change' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9828-git-p4-map-user.sh

··· 2 2 3 3 test_description='Clone repositories and map users' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9829-git-p4-jobs.sh

··· 2 2 3 3 test_description='git p4 retrieve job info' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9830-git-p4-symlink-dir.sh

··· 2 2 3 3 test_description='git p4 symlinked directories' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9831-git-p4-triggers.sh

··· 2 2 3 3 test_description='git p4 with server triggers' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9832-unshelve.sh

··· 6 6 7 7 test_description='git p4 unshelve' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./lib-git-p4.sh 11 10 12 11 test_expect_success 'start p4d' '

-1

t/t9833-errors.sh

··· 2 2 3 3 test_description='git p4 errors' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./lib-git-p4.sh 7 6 8 7 test_expect_success 'start p4d' '

-1

t/t9834-git-p4-file-dir-bug.sh

··· 6 6 checks that git-p4 recovers from the error at the same time as the perforce 7 7 repository.' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./lib-git-p4.sh 11 10 12 11 test_expect_success 'start p4d' '

-1

t/t9835-git-p4-metadata-encoding-python2.sh

··· 6 6 encoding in p4 metadata (author names, commit messages, etc) without 7 7 failing, and produces maximally sane output in git.' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./lib-git-p4.sh 11 10 12 11 python_target_version='2'

-1

t/t9836-git-p4-metadata-encoding-python3.sh

··· 6 6 encoding in p4 metadata (author names, commit messages, etc) without 7 7 failing, and produces maximally sane output in git.' 8 8 9 9 - TEST_PASSES_SANITIZE_LEAK=true 10 9 . ./lib-git-p4.sh 11 10 12 11 python_target_version='3'

-1

t/t9850-shell.sh

··· 2 2 3 3 test_description='git shell tests' 4 4 5 5 - TEST_PASSES_SANITIZE_LEAK=true 6 5 . ./test-lib.sh 7 6 8 7 test_expect_success 'shell allows upload-pack' '

-1

t/t9901-git-web--browse.sh

··· 5 5 6 6 This test checks that git web--browse can handle various valid URLs.' 7 7 8 8 - TEST_PASSES_SANITIZE_LEAK=true 9 8 . ./test-lib.sh 10 9 11 10 test_web_browse () {

-1

t/t9902-completion.sh

··· 16 16 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master 17 17 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 18 18 19 19 - TEST_PASSES_SANITIZE_LEAK=true 20 19 . ./lib-bash.sh 21 20 22 21 complete ()

-1

t/t9903-bash-prompt.sh

··· 8 8 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main 9 9 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 10 10 11 11 - TEST_PASSES_SANITIZE_LEAK=true 12 11 . ./lib-bash.sh 13 12 14 13 . "$GIT_BUILD_DIR/contrib/completion/git-prompt.sh"

+1 -71

t/test-lib.sh

··· 1180 1180 fi && 1181 1181 say_color error "$(cat "$TEST_RESULTS_SAN_FILE".*)" && 1182 1182 1183 1183 - if test -n "$passes_sanitize_leak" && test "$test_failure" = 0 1184 1184 - then 1185 1185 - say "As TEST_PASSES_SANITIZE_LEAK=true and our logs show we're leaking, exit non-zero!" && 1186 1186 - invert_exit_code=t 1187 1187 - elif test -n "$passes_sanitize_leak" 1188 1188 - then 1189 1189 - say "As TEST_PASSES_SANITIZE_LEAK=true and our logs show we're leaking, and we're failing for other reasons too..." && 1190 1190 - invert_exit_code= 1191 1191 - elif test -n "$sanitize_leak_check" && test "$test_failure" = 0 1192 1192 - then 1193 1193 - say "As TEST_PASSES_SANITIZE_LEAK=true isn't set the above leak is 'ok' with GIT_TEST_PASSING_SANITIZE_LEAK=check" && 1194 1194 - invert_exit_code= 1195 1195 - elif test -n "$sanitize_leak_check" 1196 1196 - then 1197 1197 - say "As TEST_PASSES_SANITIZE_LEAK=true isn't set the above leak is 'ok' with GIT_TEST_PASSING_SANITIZE_LEAK=check" && 1198 1198 - invert_exit_code=t 1199 1199 - elif test "$test_failure" = 0 1183 1183 + if test "$test_failure" = 0 1200 1184 then 1201 1185 say "Our logs revealed a memory leak, exit non-zero!" && 1202 1186 invert_exit_code=t ··· 1225 1209 missing_prereq $test_missing_prereq 1226 1210 1227 1211 EOF 1228 1228 - fi 1229 1229 - 1230 1230 - if test -z "$passes_sanitize_leak" && test_bool_env TEST_PASSES_SANITIZE_LEAK false 1231 1231 - then 1232 1232 - BAIL_OUT "Please, set TEST_PASSES_SANITIZE_LEAK before sourcing test-lib.sh" 1233 1212 fi 1234 1213 1235 1214 if test "$test_fixed" != 0 ··· 1518 1497 test_done 1519 1498 fi 1520 1499 1521 1521 - BAIL_OUT_ENV_NEEDS_SANITIZE_LEAK () { 1522 1522 - BAIL_OUT "$1 has no effect except when compiled with SANITIZE=leak" 1523 1523 - } 1524 1524 - 1525 1500 if test -n "$SANITIZE_LEAK" 1526 1501 then 1527 1527 - # Normalize with test_bool_env 1528 1528 - passes_sanitize_leak= 1529 1529 - 1530 1530 - # We need to see TEST_PASSES_SANITIZE_LEAK in "test-tool 1531 1531 - # env-helper" (via test_bool_env) 1532 1532 - export TEST_PASSES_SANITIZE_LEAK 1533 1533 - if test_bool_env TEST_PASSES_SANITIZE_LEAK false 1534 1534 - then 1535 1535 - passes_sanitize_leak=t 1536 1536 - fi 1537 1537 - 1538 1538 - if test "$GIT_TEST_PASSING_SANITIZE_LEAK" = "check" || 1539 1539 - test "$GIT_TEST_PASSING_SANITIZE_LEAK" = "check-failing" 1540 1540 - then 1541 1541 - if test "$GIT_TEST_PASSING_SANITIZE_LEAK" = "check-failing" && 1542 1542 - test -n "$passes_sanitize_leak" 1543 1543 - then 1544 1544 - skip_all="skipping leak-free $this_test under GIT_TEST_PASSING_SANITIZE_LEAK=check-failing" 1545 1545 - test_done 1546 1546 - fi 1547 1547 - 1548 1548 - sanitize_leak_check=t 1549 1549 - if test -n "$invert_exit_code" 1550 1550 - then 1551 1551 - BAIL_OUT "cannot use --invert-exit-code under GIT_TEST_PASSING_SANITIZE_LEAK=check" 1552 1552 - fi 1553 1553 - 1554 1554 - if test -z "$passes_sanitize_leak" 1555 1555 - then 1556 1556 - say "in GIT_TEST_PASSING_SANITIZE_LEAK=check mode, setting --invert-exit-code for TEST_PASSES_SANITIZE_LEAK != true" 1557 1557 - invert_exit_code=t 1558 1558 - fi 1559 1559 - elif test -z "$passes_sanitize_leak" && 1560 1560 - test_bool_env GIT_TEST_PASSING_SANITIZE_LEAK false 1561 1561 - then 1562 1562 - skip_all="skipping $this_test under GIT_TEST_PASSING_SANITIZE_LEAK=true" 1563 1563 - test_done 1564 1564 - fi 1565 1565 - 1566 1502 rm -rf "$TEST_RESULTS_SAN_DIR" 1567 1503 if ! mkdir -p "$TEST_RESULTS_SAN_DIR" 1568 1504 then ··· 1577 1513 prepend_var LSAN_OPTIONS : log_exe_name=1 1578 1514 prepend_var LSAN_OPTIONS : log_path="'$TEST_RESULTS_SAN_FILE'" 1579 1515 export LSAN_OPTIONS 1580 1580 - 1581 1581 - elif test "$GIT_TEST_PASSING_SANITIZE_LEAK" = "check" || 1582 1582 - test "$GIT_TEST_PASSING_SANITIZE_LEAK" = "check-failing" || 1583 1583 - test_bool_env GIT_TEST_PASSING_SANITIZE_LEAK false 1584 1584 - then 1585 1585 - BAIL_OUT_ENV_NEEDS_SANITIZE_LEAK "GIT_TEST_PASSING_SANITIZE_LEAK=true" 1586 1516 fi 1587 1517 1588 1518 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0 &&

+65

t/unit-tests/strvec.c

··· 88 88 strvec_clear(&vec); 89 89 } 90 90 91 91 + void test_strvec__splice_with_same_size_replacement(void) 92 92 + { 93 93 + struct strvec vec = STRVEC_INIT; 94 94 + const char *replacement[] = { "1" }; 95 95 + 96 96 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 97 97 + strvec_splice(&vec, 1, 1, replacement, ARRAY_SIZE(replacement)); 98 98 + check_strvec(&vec, "foo", "1", "baz", NULL); 99 99 + strvec_clear(&vec); 100 100 + } 101 101 + 102 102 + void test_strvec__splice_with_smaller_replacement(void) 103 103 + { 104 104 + struct strvec vec = STRVEC_INIT; 105 105 + const char *replacement[] = { "1" }; 106 106 + 107 107 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 108 108 + strvec_splice(&vec, 1, 2, replacement, ARRAY_SIZE(replacement)); 109 109 + check_strvec(&vec, "foo", "1", NULL); 110 110 + strvec_clear(&vec); 111 111 + } 112 112 + 113 113 + void test_strvec__splice_with_bigger_replacement(void) 114 114 + { 115 115 + struct strvec vec = STRVEC_INIT; 116 116 + const char *replacement[] = { "1", "2", "3" }; 117 117 + 118 118 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 119 119 + strvec_splice(&vec, 0, 2, replacement, ARRAY_SIZE(replacement)); 120 120 + check_strvec(&vec, "1", "2", "3", "baz", NULL); 121 121 + strvec_clear(&vec); 122 122 + } 123 123 + 124 124 + void test_strvec__splice_with_empty_replacement(void) 125 125 + { 126 126 + struct strvec vec = STRVEC_INIT; 127 127 + 128 128 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 129 129 + strvec_splice(&vec, 0, 2, NULL, 0); 130 130 + check_strvec(&vec, "baz", NULL); 131 131 + strvec_clear(&vec); 132 132 + } 133 133 + 134 134 + void test_strvec__splice_with_empty_original(void) 135 135 + { 136 136 + struct strvec vec = STRVEC_INIT; 137 137 + const char *replacement[] = { "1", "2" }; 138 138 + 139 139 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 140 140 + strvec_splice(&vec, 1, 0, replacement, ARRAY_SIZE(replacement)); 141 141 + check_strvec(&vec, "foo", "1", "2", "bar", "baz", NULL); 142 142 + strvec_clear(&vec); 143 143 + } 144 144 + 145 145 + void test_strvec__splice_at_tail(void) 146 146 + { 147 147 + struct strvec vec = STRVEC_INIT; 148 148 + const char *replacement[] = { "1", "2" }; 149 149 + 150 150 + strvec_pushl(&vec, "foo", "bar", NULL); 151 151 + strvec_splice(&vec, 2, 0, replacement, ARRAY_SIZE(replacement)); 152 152 + check_strvec(&vec, "foo", "bar", "1", "2", NULL); 153 153 + strvec_clear(&vec); 154 154 + } 155 155 + 91 156 void test_strvec__replace_at_head(void) 92 157 { 93 158 struct strvec vec = STRVEC_INIT;

-15

usage.c

··· 350 350 trace2_cmd_error_va(fmt, ap); 351 351 va_end(ap); 352 352 } 353 353 - 354 354 - #ifdef SUPPRESS_ANNOTATED_LEAKS 355 355 - void unleak_memory(const void *ptr, size_t len) 356 356 - { 357 357 - static struct suppressed_leak_root { 358 358 - struct suppressed_leak_root *next; 359 359 - char data[FLEX_ARRAY]; 360 360 - } *suppressed_leaks; 361 361 - struct suppressed_leak_root *root; 362 362 - 363 363 - FLEX_ALLOC_MEM(root, data, ptr, len); 364 364 - root->next = suppressed_leaks; 365 365 - suppressed_leaks = root; 366 366 - } 367 367 - #endif