+TLIBS = $(sort $(wildcard lib-*.sh)) annotate-tests.sh

+TINTEROP = $(sort $(wildcard interop/i[0-9][0-9][0-9][0-9]-*.sh))

+CHAINLINT = '$(PERL_PATH_SQ)' chainlint.pl

+

+# `test-chainlint` (which is a dependency of `test-lint`, `test` and `prove`)

+# checks all tests in all scripts via a single invocation, so tell individual

+# scripts not to "chainlint" themselves

+CHAINLINTSUPPRESS = GIT_TEST_CHAIN_LINT=0 && export GIT_TEST_CHAIN_LINT &&

+ $(CHAINLINTSUPPRESS) $(MAKE) aggregate-results-and-cleanup

+ @echo "*** prove ***"; $(CHAINLINTSUPPRESS) $(PROVE) --exec '$(TEST_SHELL_PATH_SQ)' $(GIT_PROVE_OPTS) $(T) :: $(GIT_TEST_OPTS)

+ $(RM) -r 'trash directory'.*

+ $(RM) -r '$(TEST_RESULTS_DIRECTORY_SQ)'

+ for i in $(CHAINLINTTESTS); do \

+ echo "test_expect_success '$$i' '" && \

+ sed -e '/^# LINT: /d' chainlint/$$i.test && \

+ echo "'"; \

+ done >'$(CHAINLINTTMP_SQ)'/tests && \

+ { \

+ echo "# chainlint: $(CHAINLINTTMP_SQ)/tests" && \

+ for i in $(CHAINLINTTESTS); do \

+ echo "# chainlint: $$i" && \

+ sed -e '/^[ ]*$$/d' chainlint/$$i.expect; \

+ done \

+ } >'$(CHAINLINTTMP_SQ)'/expect && \

+ $(CHAINLINT) --emit-all '$(CHAINLINTTMP_SQ)'/tests | \

+ grep -v '^[ ]*$$' >'$(CHAINLINTTMP_SQ)'/actual && \

+ if test -f ../GIT-BUILD-OPTIONS; then \

+ . ../GIT-BUILD-OPTIONS; \

+ fi && \

+ if test -x ../git$$X; then \

+ DIFFW="../git$$X --no-pager diff -w --no-index"; \

+ else \

+ DIFFW="diff -w -u"; \

+ fi && \

+ $$DIFFW '$(CHAINLINTTMP_SQ)'/expect '$(CHAINLINTTMP_SQ)'/actual

+ifneq ($(GIT_TEST_CHAIN_LINT),0)

+test-lint: test-chainlint

+endif

+test-chainlint:

+ @$(CHAINLINT) $(T) $(TLIBS) $(TPERF) $(TINTEROP)

+

+.PHONY: pre-clean $(T) aggregate-results clean valgrind perf \

+ check-chainlint clean-chainlint test-chainlint

+GIT_TEST_PASSING_SANITIZE_LEAK=true skips those tests that haven't

+declared themselves as leak-free by setting

+"TEST_PASSES_SANITIZE_LEAK=true" before sourcing "test-lib.sh". This

+test mode is used by the "linux-leaks" CI target.

+

+GIT_TEST_PASSING_SANITIZE_LEAK=check checks that our

+"TEST_PASSES_SANITIZE_LEAK=true" markings are current. Rather than

+skipping those tests that haven't set "TEST_PASSES_SANITIZE_LEAK=true"

+before sourcing "test-lib.sh" this mode runs them with

+"--invert-exit-code". This is used to check that there's a one-to-one

+mapping between "TEST_PASSES_SANITIZE_LEAK=true" and those tests that

+pass under "SANITIZE=leak". This is especially useful when testing a

+series that fixes various memory leaks with "git rebase -x".

+

+GIT_TEST_SANITIZE_LEAK_LOG=true will log memory leaks to

+"test-results/$TEST_NAME.leak/trace.*" files. The logs include a

+"dedup_token" (see +"ASAN_OPTIONS=help=1 ./git") and other options to

+make logs +machine-readable.

+

+With GIT_TEST_SANITIZE_LEAK_LOG=true we'll look at the leak logs

+before exiting and exit on failure if the logs showed that we had a

+memory leak, even if the test itself would have otherwise passed. This

+allows us to catch e.g. missing &&-chaining. This is especially useful

+when combined with "GIT_TEST_PASSING_SANITIZE_LEAK", see below.

+

+GIT_TEST_PASSING_SANITIZE_LEAK=check when combined with "--immediate"

+will run to completion faster, and result in the same failing

+tests. The only practical reason to run

+GIT_TEST_PASSING_SANITIZE_LEAK=check without "--immediate" is to

+combine it with "GIT_TEST_SANITIZE_LEAK_LOG=true". If we stop at the

+first failing test case our leak logs won't show subsequent leaks we

+might have run into.

+

+GIT_TEST_PASSING_SANITIZE_LEAK=(true|check) will not catch all memory

+leaks unless combined with GIT_TEST_SANITIZE_LEAK_LOG=true. Some tests

+run "git" (or "test-tool" etc.) without properly checking the exit

+code, or git will invoke itself and fail to ferry the abort() exit

+code to the original caller. When the two modes are combined we'll

+look at the "test-results/$TEST_NAME.leak/trace.*" files at the end of

+the test run to see if had memory leaks which the test itself didn't

+catch.

+ test_when_finished "rm -rf .git/info" &&

+ mkdir .git/info &&

+#!/usr/bin/env perl

+#

+# Copyright (c) 2021-2022 Eric Sunshine <sunshine@sunshineco.com>

+#

+# This tool scans shell scripts for test definitions and checks those tests for

+# problems, such as broken &&-chains, which might hide bugs in the tests

+# themselves or in behaviors being exercised by the tests.

+#

+# Input arguments are pathnames of shell scripts containing test definitions,

+# or globs referencing a collection of scripts. For each problem discovered,

+# the pathname of the script containing the test is printed along with the test

+# name and the test body with a `?!FOO?!` annotation at the location of each

+# detected problem, where "FOO" is a tag such as "AMP" which indicates a broken

+# &&-chain. Returns zero if no problems are discovered, otherwise non-zero.

+

+use warnings;

+use strict;

+use Config;

+use File::Glob;

+use Getopt::Long;

+

+my $jobs = -1;

+my $show_stats;

+my $emit_all;

+

+# Lexer tokenizes POSIX shell scripts. It is roughly modeled after section 2.3

+# "Token Recognition" of POSIX chapter 2 "Shell Command Language". Although

+# similar to lexical analyzers for other languages, this one differs in a few

+# substantial ways due to quirks of the shell command language.

+#

+# For instance, in many languages, newline is just whitespace like space or

+# TAB, but in shell a newline is a command separator, thus a distinct lexical

+# token. A newline is significant and returned as a distinct token even at the

+# end of a shell comment.

+#

+# In other languages, `1+2` would typically be scanned as three tokens

+# (`1`, `+`, and `2`), but in shell it is a single token. However, the similar

+# `1 + 2`, which embeds whitepace, is scanned as three token in shell, as well.

+# In shell, several characters with special meaning lose that meaning when not

+# surrounded by whitespace. For instance, the negation operator `!` is special

+# when standing alone surrounded by whitespace; whereas in `foo!uucp` it is

+# just a plain character in the longer token "foo!uucp". In many other

+# languages, `"string"/foo:'string'` might be scanned as five tokens ("string",

+# `/`, `foo`, `:`, and 'string'), but in shell, it is just a single token.

+#

+# The lexical analyzer for the shell command language is also somewhat unusual

+# in that it recursively invokes the parser to handle the body of `$(...)`

+# expressions which can contain arbitrary shell code. Such expressions may be

+# encountered both inside and outside of double-quoted strings.

+#

+# The lexical analyzer is responsible for consuming shell here-doc bodies which

+# extend from the line following a `<<TAG` operator until a line consisting

+# solely of `TAG`. Here-doc consumption begins when a newline is encountered.

+# It is legal for multiple here-doc `<<TAG` operators to be present on a single

+# line, in which case their bodies must be present one following the next, and

+# are consumed in the (left-to-right) order the `<<TAG` operators appear on the

+# line. A special complication is that the bodies of all here-docs must be

+# consumed when the newline is encountered even if the parse context depth has

+# changed. For instance, in `cat <<A && x=$(cat <<B &&\n`, bodies of here-docs

+# "A" and "B" must be consumed even though "A" was introduced outside the

+# recursive parse context in which "B" was introduced and in which the newline

+# is encountered.

+package Lexer;

+

+sub new {

+ my ($class, $parser, $s) = @_;

+ bless {

+ parser => $parser,

+ buff => $s,

+ heretags => []

+ } => $class;

+}

+

+sub scan_heredoc_tag {

+ my $self = shift @_;

+ ${$self->{buff}} =~ /\G(-?)/gc;

+ my $indented = $1;

+ my $tag = $self->scan_token();

+ $tag =~ s/['"\\]//g;

+ push(@{$self->{heretags}}, $indented ? "\t$tag" : "$tag");

+ return "<<$indented$tag";

+}

+

+sub scan_op {

+ my ($self, $c) = @_;

+ my $b = $self->{buff};

+ return $c unless $$b =~ /\G(.)/sgc;

+ my $cc = $c . $1;

+ return scan_heredoc_tag($self) if $cc eq '<<';

+ return $cc if $cc =~ /^(?:&&|\|\||>>|;;|<&|>&|<>|>\|)$/;

+ pos($$b)--;

+ return $c;

+}

+

+sub scan_sqstring {

+ my $self = shift @_;

+ ${$self->{buff}} =~ /\G([^']*'|.*\z)/sgc;

+ return "'" . $1;

+}

+

+sub scan_dqstring {

+ my $self = shift @_;

+ my $b = $self->{buff};

+ my $s = '"';

+ while (1) {

+ # slurp up non-special characters

+ $s .= $1 if $$b =~ /\G([^"\$\\]+)/gc;

+ # handle special characters

+ last unless $$b =~ /\G(.)/sgc;

+ my $c = $1;

+ $s .= '"', last if $c eq '"';

+ $s .= '$' . $self->scan_dollar(), next if $c eq '$';

+ if ($c eq '\\') {

+ $s .= '\\', last unless $$b =~ /\G(.)/sgc;

+ $c = $1;

+ next if $c eq "\n"; # line splice

+ # backslash escapes only $, `, ", \ in dq-string

+ $s .= '\\' unless $c =~ /^[\$`"\\]$/;

+ $s .= $c;

+ next;

+ }

+ die("internal error scanning dq-string '$c'\n");

+ }

+ return $s;

+}

+

+sub scan_balanced {

+ my ($self, $c1, $c2) = @_;

+ my $b = $self->{buff};

+ my $depth = 1;

+ my $s = $c1;

+ while ($$b =~ /\G([^\Q$c1$c2\E]*(?:[\Q$c1$c2\E]|\z))/gc) {

+ $s .= $1;

+ $depth++, next if $s =~ /\Q$c1\E$/;

+ $depth--;

+ last if $depth == 0;

+ }

+ return $s;

+}

+

+sub scan_subst {

+ my $self = shift @_;

+ my @tokens = $self->{parser}->parse(qr/^\)$/);

+ $self->{parser}->next_token(); # closing ")"

+ return @tokens;

+}

+

+sub scan_dollar {

+ my $self = shift @_;

+ my $b = $self->{buff};

+ return $self->scan_balanced('(', ')') if $$b =~ /\G\((?=\()/gc; # $((...))

+ return '(' . join(' ', $self->scan_subst()) . ')' if $$b =~ /\G\(/gc; # $(...)

+ return $self->scan_balanced('{', '}') if $$b =~ /\G\{/gc; # ${...}

+ return $1 if $$b =~ /\G(\w+)/gc; # $var

+ return $1 if $$b =~ /\G([@*#?$!0-9-])/gc; # $*, $1, $$, etc.

+ return '';

+}

+

+sub swallow_heredocs {

+ my $self = shift @_;

+ my $b = $self->{buff};

+ my $tags = $self->{heretags};

+ while (my $tag = shift @$tags) {

+ my $indent = $tag =~ s/^\t// ? '\\s*' : '';

+ $$b =~ /(?:\G|\n)$indent\Q$tag\E(?:\n|\z)/gc;

+ }

+}

+

+sub scan_token {

+ my $self = shift @_;

+ my $b = $self->{buff};

+ my $token = '';

+RESTART:

+ $$b =~ /\G[ \t]+/gc; # skip whitespace (but not newline)

+ return "\n" if $$b =~ /\G#[^\n]*(?:\n|\z)/gc; # comment

+ while (1) {

+ # slurp up non-special characters

+ $token .= $1 if $$b =~ /\G([^\\;&|<>(){}'"\$\s]+)/gc;

+ # handle special characters

+ last unless $$b =~ /\G(.)/sgc;

+ my $c = $1;

+ last if $c =~ /^[ \t]$/; # whitespace ends token

+ pos($$b)--, last if length($token) && $c =~ /^[;&|<>(){}\n]$/;

+ $token .= $self->scan_sqstring(), next if $c eq "'";

+ $token .= $self->scan_dqstring(), next if $c eq '"';

+ $token .= $c . $self->scan_dollar(), next if $c eq '$';

+ $self->swallow_heredocs(), $token = $c, last if $c eq "\n";

+ $token = $self->scan_op($c), last if $c =~ /^[;&|<>]$/;

+ $token = $c, last if $c =~ /^[(){}]$/;

+ if ($c eq '\\') {

+ $token .= '\\', last unless $$b =~ /\G(.)/sgc;

+ $c = $1;

+ next if $c eq "\n" && length($token); # line splice

+ goto RESTART if $c eq "\n"; # line splice

+ $token .= '\\' . $c;

+ next;

+ }

+ die("internal error scanning character '$c'\n");

+ }

+ return length($token) ? $token : undef;

+}

+

+# ShellParser parses POSIX shell scripts (with minor extensions for Bash). It

+# is a recursive descent parser very roughly modeled after section 2.10 "Shell

+# Grammar" of POSIX chapter 2 "Shell Command Language".

+package ShellParser;

+

+sub new {

+ my ($class, $s) = @_;

+ my $self = bless {

+ buff => [],

+ stop => [],

+ output => []

+ } => $class;

+ $self->{lexer} = Lexer->new($self, $s);

+ return $self;

+}

+

+sub next_token {

+ my $self = shift @_;

+ return pop(@{$self->{buff}}) if @{$self->{buff}};

+ return $self->{lexer}->scan_token();

+}

+

+sub untoken {

+ my $self = shift @_;

+ push(@{$self->{buff}}, @_);

+}

+

+sub peek {

+ my $self = shift @_;

+ my $token = $self->next_token();

+ return undef unless defined($token);

+ $self->untoken($token);

+ return $token;

+}

+

+sub stop_at {

+ my ($self, $token) = @_;

+ return 1 unless defined($token);

+ my $stop = ${$self->{stop}}[-1] if @{$self->{stop}};

+ return defined($stop) && $token =~ $stop;

+}

+

+sub expect {

+ my ($self, $expect) = @_;

+ my $token = $self->next_token();

+ return $token if defined($token) && $token eq $expect;

+ push(@{$self->{output}}, "?!ERR?! expected '$expect' but found '" . (defined($token) ? $token : "<end-of-input>") . "'\n");

+ $self->untoken($token) if defined($token);

+ return ();

+}

+

+sub optional_newlines {

+ my $self = shift @_;

+ my @tokens;

+ while (my $token = $self->peek()) {

+ last unless $token eq "\n";

+ push(@tokens, $self->next_token());

+ }

+ return @tokens;

+}

+

+sub parse_group {

+ my $self = shift @_;

+ return ($self->parse(qr/^}$/),

+ $self->expect('}'));

+}

+

+sub parse_subshell {

+ my $self = shift @_;

+ return ($self->parse(qr/^\)$/),

+ $self->expect(')'));

+}

+

+sub parse_case_pattern {

+ my $self = shift @_;

+ my @tokens;

+ while (defined(my $token = $self->next_token())) {

+ push(@tokens, $token);

+ last if $token eq ')';

+ }

+ return @tokens;

+}

+

+sub parse_case {

+ my $self = shift @_;

+ my @tokens;

+ push(@tokens,

+ $self->next_token(), # subject

+ $self->optional_newlines(),

+ $self->expect('in'),

+ $self->optional_newlines());

+ while (1) {

+ my $token = $self->peek();

+ last unless defined($token) && $token ne 'esac';

+ push(@tokens,

+ $self->parse_case_pattern(),

+ $self->optional_newlines(),

+ $self->parse(qr/^(?:;;|esac)$/)); # item body

+ $token = $self->peek();

+ last unless defined($token) && $token ne 'esac';

+ push(@tokens,

+ $self->expect(';;'),

+ $self->optional_newlines());

+ }

+ push(@tokens, $self->expect('esac'));

+ return @tokens;

+}

+

+sub parse_for {

+ my $self = shift @_;

+ my @tokens;

+ push(@tokens,

+ $self->next_token(), # variable

+ $self->optional_newlines());

+ my $token = $self->peek();

+ if (defined($token) && $token eq 'in') {

+ push(@tokens,

+ $self->expect('in'),

+ $self->optional_newlines());

+ }

+ push(@tokens,

+ $self->parse(qr/^do$/), # items

+ $self->expect('do'),

+ $self->optional_newlines(),

+ $self->parse_loop_body(),

+ $self->expect('done'));

+ return @tokens;

+}

+

+sub parse_if {

+ my $self = shift @_;

+ my @tokens;

+ while (1) {

+ push(@tokens,

+ $self->parse(qr/^then$/), # if/elif condition

+ $self->expect('then'),

+ $self->optional_newlines(),

+ $self->parse(qr/^(?:elif|else|fi)$/)); # if/elif body

+ my $token = $self->peek();

+ last unless defined($token) && $token eq 'elif';

+ push(@tokens, $self->expect('elif'));

+ }

+ my $token = $self->peek();

+ if (defined($token) && $token eq 'else') {

+ push(@tokens,

+ $self->expect('else'),

+ $self->optional_newlines(),

+ $self->parse(qr/^fi$/)); # else body

+ }

+ push(@tokens, $self->expect('fi'));

+ return @tokens;

+}

+

+sub parse_loop_body {

+ my $self = shift @_;

+ return $self->parse(qr/^done$/);

+}

+

+sub parse_loop {

+ my $self = shift @_;

+ return ($self->parse(qr/^do$/), # condition

+ $self->expect('do'),

+ $self->optional_newlines(),

+ $self->parse_loop_body(),

+ $self->expect('done'));

+}

+

+sub parse_func {

+ my $self = shift @_;

+ return ($self->expect('('),

+ $self->expect(')'),

+ $self->optional_newlines(),

+ $self->parse_cmd()); # body

+}

+

+sub parse_bash_array_assignment {

+ my $self = shift @_;

+ my @tokens = $self->expect('(');

+ while (defined(my $token = $self->next_token())) {

+ push(@tokens, $token);

+ last if $token eq ')';

+ }

+ return @tokens;

+}

+

+my %compound = (

+ '{' => \&parse_group,

+ '(' => \&parse_subshell,

+ 'case' => \&parse_case,

+ 'for' => \&parse_for,

+ 'if' => \&parse_if,

+ 'until' => \&parse_loop,

+ 'while' => \&parse_loop);

+

+sub parse_cmd {

+ my $self = shift @_;

+ my $cmd = $self->next_token();

+ return () unless defined($cmd);

+ return $cmd if $cmd eq "\n";

+

+ my $token;

+ my @tokens = $cmd;

+ if ($cmd eq '!') {

+ push(@tokens, $self->parse_cmd());

+ return @tokens;

+ } elsif (my $f = $compound{$cmd}) {

+ push(@tokens, $self->$f());

+ } elsif (defined($token = $self->peek()) && $token eq '(') {

+ if ($cmd !~ /\w=$/) {

+ push(@tokens, $self->parse_func());

+ return @tokens;

+ }

+ $tokens[-1] .= join(' ', $self->parse_bash_array_assignment());

+ }

+

+ while (defined(my $token = $self->next_token())) {

+ $self->untoken($token), last if $self->stop_at($token);

+ push(@tokens, $token);

+ last if $token =~ /^(?:[;&\n|]|&&|\|\|)$/;

+ }

+ push(@tokens, $self->next_token()) if $tokens[-1] ne "\n" && defined($token = $self->peek()) && $token eq "\n";

+ return @tokens;

+}

+

+sub accumulate {

+ my ($self, $tokens, $cmd) = @_;

+ push(@$tokens, @$cmd);

+}

+

+sub parse {

+ my ($self, $stop) = @_;

+ push(@{$self->{stop}}, $stop);

+ goto DONE if $self->stop_at($self->peek());

+ my @tokens;

+ while (my @cmd = $self->parse_cmd()) {

+ $self->accumulate(\@tokens, \@cmd);

+ last if $self->stop_at($self->peek());

+ }

+DONE:

+ pop(@{$self->{stop}});

+ return @tokens;

+}

+

+# TestParser is a subclass of ShellParser which, beyond parsing shell script

+# code, is also imbued with semantic knowledge of test construction, and checks

+# tests for common problems (such as broken &&-chains) which might hide bugs in

+# the tests themselves or in behaviors being exercised by the tests. As such,

+# TestParser is only called upon to parse test bodies, not the top-level

+# scripts in which the tests are defined.

+package TestParser;

+

+use base 'ShellParser';

+

+sub find_non_nl {

+ my $tokens = shift @_;

+ my $n = shift @_;

+ $n = $#$tokens if !defined($n);

+ $n-- while $n >= 0 && $$tokens[$n] eq "\n";

+ return $n;

+}

+

+sub ends_with {

+ my ($tokens, $needles) = @_;

+ my $n = find_non_nl($tokens);

+ for my $needle (reverse(@$needles)) {

+ return undef if $n < 0;

+ $n = find_non_nl($tokens, $n), next if $needle eq "\n";

+ return undef if $$tokens[$n] !~ $needle;

+ $n--;

+ }

+ return 1;

+}

+

+sub match_ending {

+ my ($tokens, $endings) = @_;

+ for my $needles (@$endings) {

+ next if @$tokens < scalar(grep {$_ ne "\n"} @$needles);

+ return 1 if ends_with($tokens, $needles);

+ }

+ return undef;

+}

+

+sub parse_loop_body {

+ my $self = shift @_;

+ my @tokens = $self->SUPER::parse_loop_body(@_);

+ # did loop signal failure via "|| return" or "|| exit"?

+ return @tokens if !@tokens || grep(/^(?:return|exit|\$\?)$/, @tokens);

+ # did loop upstream of a pipe signal failure via "|| echo 'impossible

+ # text'" as the final command in the loop body?

+ return @tokens if ends_with(\@tokens, [qr/^\|\|$/, "\n", qr/^echo$/, qr/^.+$/]);

+ # flag missing "return/exit" handling explicit failure in loop body

+ my $n = find_non_nl(\@tokens);

+ splice(@tokens, $n + 1, 0, '?!LOOP?!');

+ return @tokens;

+}

+

+my @safe_endings = (

+ [qr/^(?:&&|\|\||\||&)$/],

+ [qr/^(?:exit|return)$/, qr/^(?:\d+|\$\?)$/],

+ [qr/^(?:exit|return)$/, qr/^(?:\d+|\$\?)$/, qr/^;$/],

+ [qr/^(?:exit|return|continue)$/],

+ [qr/^(?:exit|return|continue)$/, qr/^;$/]);

+

+sub accumulate {

+ my ($self, $tokens, $cmd) = @_;

+ goto DONE unless @$tokens;

+ goto DONE if @$cmd == 1 && $$cmd[0] eq "\n";

+

+ # did previous command end with "&&", "|", "|| return" or similar?

+ goto DONE if match_ending($tokens, \@safe_endings);

+

+ # if this command handles "$?" specially, then okay for previous

+ # command to be missing "&&"

+ for my $token (@$cmd) {

+ goto DONE if $token =~ /\$\?/;

+ }

+

+ # if this command is "false", "return 1", or "exit 1" (which signal

+ # failure explicitly), then okay for all preceding commands to be

+ # missing "&&"

+ if ($$cmd[0] =~ /^(?:false|return|exit)$/) {

+ @$tokens = grep(!/^\?!AMP\?!$/, @$tokens);

+ goto DONE;

+ }

+

+ # flag missing "&&" at end of previous command

+ my $n = find_non_nl($tokens);

+ splice(@$tokens, $n + 1, 0, '?!AMP?!') unless $n < 0;

+

+DONE:

+ $self->SUPER::accumulate($tokens, $cmd);

+}

+

+# ScriptParser is a subclass of ShellParser which identifies individual test

+# definitions within test scripts, and passes each test body through TestParser

+# to identify possible problems. ShellParser detects test definitions not only

+# at the top-level of test scripts but also within compound commands such as

+# loops and function definitions.

+package ScriptParser;

+

+use base 'ShellParser';

+

+sub new {

+ my $class = shift @_;

+ my $self = $class->SUPER::new(@_);

+ $self->{ntests} = 0;

+ return $self;

+}

+

+# extract the raw content of a token, which may be a single string or a

+# composition of multiple strings and non-string character runs; for instance,

+# `"test body"` unwraps to `test body`; `word"a b"42'c d'` to `worda b42c d`

+sub unwrap {

+ my $token = @_ ? shift @_ : $_;

+ # simple case: 'sqstring' or "dqstring"

+ return $token if $token =~ s/^'([^']*)'$/$1/;

+ return $token if $token =~ s/^"([^"]*)"$/$1/;

+

+ # composite case

+ my ($s, $q, $escaped);

+ while (1) {

+ # slurp up non-special characters

+ $s .= $1 if $token =~ /\G([^\\'"]*)/gc;

+ # handle special characters

+ last unless $token =~ /\G(.)/sgc;

+ my $c = $1;

+ $q = undef, next if defined($q) && $c eq $q;

+ $q = $c, next if !defined($q) && $c =~ /^['"]$/;

+ if ($c eq '\\') {

+ last unless $token =~ /\G(.)/sgc;

+ $c = $1;

+ $s .= '\\' if $c eq "\n"; # preserve line splice

+ }

+ $s .= $c;

+ }

+ return $s

+}

+

+sub check_test {

+ my $self = shift @_;

+ my ($title, $body) = map(unwrap, @_);

+ $self->{ntests}++;

+ my $parser = TestParser->new(\$body);

+ my @tokens = $parser->parse();

+ return unless $emit_all || grep(/\?![^?]+\?!/, @tokens);

+ my $c = main::fd_colors(1);

+ my $checked = join(' ', @tokens);

+ $checked =~ s/^\n//;

+ $checked =~ s/^ //mg;

+ $checked =~ s/ $//mg;

+ $checked =~ s/(\?![^?]+\?!)/$c->{rev}$c->{red}$1$c->{reset}/mg;

+ $checked .= "\n" unless $checked =~ /\n$/;

+ push(@{$self->{output}}, "$c->{blue}# chainlint: $title$c->{reset}\n$checked");

+}

+

+sub parse_cmd {

+ my $self = shift @_;

+ my @tokens = $self->SUPER::parse_cmd();

+ return @tokens unless @tokens && $tokens[0] =~ /^test_expect_(?:success|failure)$/;

+ my $n = $#tokens;

+ $n-- while $n >= 0 && $tokens[$n] =~ /^(?:[;&\n|]|&&|\|\|)$/;

+ $self->check_test($tokens[1], $tokens[2]) if $n == 2; # title body

+ $self->check_test($tokens[2], $tokens[3]) if $n > 2; # prereq title body

+ return @tokens;

+}

+

+# main contains high-level functionality for processing command-line switches,

+# feeding input test scripts to ScriptParser, and reporting results.

+package main;

+

+my $getnow = sub { return time(); };

+my $interval = sub { return time() - shift; };

+if (eval {require Time::HiRes; Time::HiRes->import(); 1;}) {

+ $getnow = sub { return [Time::HiRes::gettimeofday()]; };

+ $interval = sub { return Time::HiRes::tv_interval(shift); };

+}

+

+# Restore TERM if test framework set it to "dumb" so 'tput' will work; do this

+# outside of get_colors() since under 'ithreads' all threads use %ENV of main

+# thread and ignore %ENV changes in subthreads.

+$ENV{TERM} = $ENV{USER_TERM} if $ENV{USER_TERM};

+

+my @NOCOLORS = (bold => '', rev => '', reset => '', blue => '', green => '', red => '');

+my %COLORS = ();

+sub get_colors {

+ return \%COLORS if %COLORS;

+ if (exists($ENV{NO_COLOR}) ||

+ system("tput sgr0 >/dev/null 2>&1") != 0 ||

+ system("tput bold >/dev/null 2>&1") != 0 ||

+ system("tput rev >/dev/null 2>&1") != 0 ||

+ system("tput setaf 1 >/dev/null 2>&1") != 0) {

+ %COLORS = @NOCOLORS;

+ return \%COLORS;

+ }

+ %COLORS = (bold => `tput bold`,

+ rev => `tput rev`,

+ reset => `tput sgr0`,

+ blue => `tput setaf 4`,

+ green => `tput setaf 2`,

+ red => `tput setaf 1`);

+ chomp(%COLORS);

+ return \%COLORS;

+}

+

+my %FD_COLORS = ();

+sub fd_colors {

+ my $fd = shift;

+ return $FD_COLORS{$fd} if exists($FD_COLORS{$fd});

+ $FD_COLORS{$fd} = -t $fd ? get_colors() : {@NOCOLORS};

+ return $FD_COLORS{$fd};

+}

+

+sub ncores {

+ # Windows

+ return $ENV{NUMBER_OF_PROCESSORS} if exists($ENV{NUMBER_OF_PROCESSORS});

+ # Linux / MSYS2 / Cygwin / WSL

+ do { local @ARGV='/proc/cpuinfo'; return scalar(grep(/^processor\s*:/, <>)); } if -r '/proc/cpuinfo';

+ # macOS & BSD

+ return qx/sysctl -n hw.ncpu/ if $^O =~ /(?:^darwin$|bsd)/;

+ return 1;

+}

+

+sub show_stats {

+ my ($start_time, $stats) = @_;

+ my $walltime = $interval->($start_time);

+ my ($usertime) = times();

+ my ($total_workers, $total_scripts, $total_tests, $total_errs) = (0, 0, 0, 0);

+ my $c = fd_colors(2);

+ print(STDERR $c->{green});

+ for (@$stats) {

+ my ($worker, $nscripts, $ntests, $nerrs) = @$_;

+ print(STDERR "worker $worker: $nscripts scripts, $ntests tests, $nerrs errors\n");

+ $total_workers++;

+ $total_scripts += $nscripts;

+ $total_tests += $ntests;

+ $total_errs += $nerrs;

+ }

+ printf(STDERR "total: %d workers, %d scripts, %d tests, %d errors, %.2fs/%.2fs (wall/user)$c->{reset}\n", $total_workers, $total_scripts, $total_tests, $total_errs, $walltime, $usertime);

+}

+

+sub check_script {

+ my ($id, $next_script, $emit) = @_;

+ my ($nscripts, $ntests, $nerrs) = (0, 0, 0);

+ while (my $path = $next_script->()) {

+ $nscripts++;

+ my $fh;

+ unless (open($fh, "<", $path)) {

+ $emit->("?!ERR?! $path: $!\n");

+ next;

+ }

+ my $s = do { local $/; <$fh> };

+ close($fh);

+ my $parser = ScriptParser->new(\$s);

+ 1 while $parser->parse_cmd();

+ if (@{$parser->{output}}) {

+ my $c = fd_colors(1);

+ my $s = join('', @{$parser->{output}});

+ $emit->("$c->{bold}$c->{blue}# chainlint: $path$c->{reset}\n" . $s);

+ $nerrs += () = $s =~ /\?![^?]+\?!/g;

+ }

+ $ntests += $parser->{ntests};

+ }

+ return [$id, $nscripts, $ntests, $nerrs];

+}

+

+sub exit_code {

+ my $stats = shift @_;

+ for (@$stats) {

+ my ($worker, $nscripts, $ntests, $nerrs) = @$_;

+ return 1 if $nerrs;

+ }

+ return 0;

+}

+

+Getopt::Long::Configure(qw{bundling});

+GetOptions(

+ "emit-all!" => \$emit_all,

+ "jobs|j=i" => \$jobs,

+ "stats|show-stats!" => \$show_stats) or die("option error\n");

+$jobs = ncores() if $jobs < 1;

+

+my $start_time = $getnow->();

+my @stats;

+

+my @scripts;

+push(@scripts, File::Glob::bsd_glob($_)) for (@ARGV);

+unless (@scripts) {

+ show_stats($start_time, \@stats) if $show_stats;

+ exit;

+}

+

+unless ($Config{useithreads} && eval {

+ require threads; threads->import();

+ require Thread::Queue; Thread::Queue->import();

+ 1;

+ }) {

+ push(@stats, check_script(1, sub { shift(@scripts); }, sub { print(@_); }));

+ show_stats($start_time, \@stats) if $show_stats;

+ exit(exit_code(\@stats));

+}

+

+my $script_queue = Thread::Queue->new();

+my $output_queue = Thread::Queue->new();

+

+sub next_script { return $script_queue->dequeue(); }

+sub emit { $output_queue->enqueue(@_); }

+

+sub monitor {

+ while (my $s = $output_queue->dequeue()) {

+ print($s);

+ }

+}

+

+my $mon = threads->create({'context' => 'void'}, \&monitor);

+threads->create({'context' => 'list'}, \&check_script, $_, \&next_script, \&emit) for 1..$jobs;

+

+$script_queue->enqueue(@scripts);

+$script_queue->end();

+

+for (threads->list()) {

+ push(@stats, $_->join()) unless $_ == $mon;

+}

+

+$output_queue->end();

+$mon->join();

+

+show_stats($start_time, \@stats) if $show_stats;

+exit(exit_code(\@stats));

+test_done ( ) {

+ case "$test_failure" in

+ 0 )

+ test_at_end_hook_

+

+ exit 0 ;;

+

+ * )

+ if test $test_external_has_tap -eq 0

+ then

+ say_color error "# failed $test_failure among $msg"

+ say "1..$test_count"

+ fi

+

+ exit 1 ;;

+

+ esac

+}

+# LINT: blank line before "esac"

+test_done () {

+ case "$test_failure" in

+ 0)

+ test_at_end_hook_

+

+ exit 0 ;;

+

+ *)

+ if test $test_external_has_tap -eq 0

+ then

+ say_color error "# failed $test_failure among $msg"

+ say "1..$test_count"

+ fi

+

+ exit 1 ;;

+

+ esac

+}

+ echo a ?!AMP?!

+) &&

+

+{

+ echo a ; ?!AMP?! echo b

+} &&

+{ echo a ; ?!AMP?! echo b ; } &&

+

+{

+ echo "${var}9" &&

+ echo "done"

+} &&

+finis

+) &&

+

+# LINT: ";" not allowed in place of "&&"

+{

+ echo a; echo b

+} &&

+{ echo a; echo b; } &&

+

+# LINT: "}" inside string not mistaken as end of block

+{

+ echo "${var}9" &&

+ echo "done"

+} &&

+finis

+JGIT_DAEMON_PID= &&

+git init --bare empty.git &&

+> empty.git/git-daemon-export-ok &&

+mkfifo jgit_daemon_output &&

+{

+ jgit daemon --port="$JGIT_DAEMON_PORT" . > jgit_daemon_output &

+ JGIT_DAEMON_PID=$!

+} &&

+test_expect_code 2 git ls-remote --exit-code git://localhost:$JGIT_DAEMON_PORT/empty.git

+JGIT_DAEMON_PID= &&

+git init --bare empty.git &&

+>empty.git/git-daemon-export-ok &&

+mkfifo jgit_daemon_output &&

+{

+# LINT: exit status of "&" is always 0 so &&-chaining immaterial

+ jgit daemon --port="$JGIT_DAEMON_PORT" . >jgit_daemon_output &

+ JGIT_DAEMON_PID=$!

+} &&

+test_expect_code 2 git ls-remote --exit-code git://localhost:$JGIT_DAEMON_PORT/empty.git

+git ls-tree --name-only -r refs/notes/many_notes |

+while read path

+do

+ test "$path" = "foobar/non-note.txt" && continue

+ test "$path" = "deadbeef" && continue

+ test "$path" = "de/adbeef" && continue

+

+ if test $(expr length "$path") -ne $hexsz

+ then

+ return 1

+ fi

+done

+git ls-tree --name-only -r refs/notes/many_notes |

+while read path

+do

+# LINT: broken &&-chain okay if explicit "continue"

+ test "$path" = "foobar/non-note.txt" && continue

+ test "$path" = "deadbeef" && continue

+ test "$path" = "de/adbeef" && continue

+

+ if test $(expr length "$path") -ne $hexsz

+ then

+ return 1

+ fi

+done

+if condition not satisified

+then

+ echo it did not work...

+ echo failed!

+ false

+else

+ echo it went okay ?!AMP?!

+ congratulate user

+fi

+# LINT: broken &&-chain okay if explicit "false" signals failure

+if condition not satisified

+then

+ echo it did not work...

+ echo failed!

+ false

+else

+ echo it went okay

+ congratulate user

+fi

+case "$(git ls-files)" in

+one ) echo pass one ;;

+* ) echo bad one ; return 1 ;;

+esac &&

+(

+ case "$(git ls-files)" in

+ two ) echo pass two ;;

+ * ) echo bad two ; exit 1 ;;

+esac

+) &&

+case "$(git ls-files)" in

+dir/two"$LF"one ) echo pass both ;;

+* ) echo bad ; return 1 ;;

+esac &&

+

+for i in 1 2 3 4 ; do

+ git checkout main -b $i || return $?

+ test_commit $i $i $i tag$i || return $?

+done

+case "$(git ls-files)" in

+one) echo pass one ;;

+# LINT: broken &&-chain okay if explicit "return 1" signals failuire

+*) echo bad one; return 1 ;;

+esac &&

+(

+ case "$(git ls-files)" in

+ two) echo pass two ;;

+# LINT: broken &&-chain okay if explicit "exit 1" signals failuire

+ *) echo bad two; exit 1 ;;

+ esac

+) &&

+case "$(git ls-files)" in

+dir/two"$LF"one) echo pass both ;;

+# LINT: broken &&-chain okay if explicit "return 1" signals failuire

+*) echo bad; return 1 ;;

+esac &&

+

+for i in 1 2 3 4 ; do

+# LINT: broken &&-chain okay if explicit "return $?" signals failure

+ git checkout main -b $i || return $?

+ test_commit $i $i $i tag$i || return $?

+done

+OUT=$(( ( large_git ; echo $? 1 >& 3 ) | : ) 3 >& 1) &&

+test_match_signal 13 "$OUT" &&

+

+{ test-tool sigchain > actual ; ret=$? ; } &&

+{

+ test_match_signal 15 "$ret" ||

+ test "$ret" = 3

+} &&

+test_cmp expect actual

+# LINT: broken &&-chain okay if next command handles "$?" explicitly

+OUT=$( ((large_git; echo $? 1>&3) | :) 3>&1 ) &&

+test_match_signal 13 "$OUT" &&

+

+# LINT: broken &&-chain okay if next command handles "$?" explicitly

+{ test-tool sigchain >actual; ret=$?; } &&

+{

+ test_match_signal 15 "$ret" ||

+ test "$ret" = 3

+} &&

+test_cmp expect actual

+echo nobody home && {

+ test the doohicky ?!AMP?!

+ right now

+} &&

+

+GIT_EXTERNAL_DIFF=echo git diff | {

+ read path oldfile oldhex oldmode newfile newhex newmode &&

+ test "z$oh" = "z$oldhex"

+}

+# LINT: start of block chained to preceding command

+echo nobody home && {

+ test the doohicky

+ right now

+} &&

+

+# LINT: preceding command pipes to block on same line

+GIT_EXTERNAL_DIFF=echo git diff | {

+ read path oldfile oldhex oldmode newfile newhex newmode &&

+ test "z$oh" = "z$oldhex"

+}

+mkdir sub && (

+ cd sub &&

+ foo the bar ?!AMP?!

+ nuff said

+) &&

+

+cut "-d " -f actual | ( read s1 s2 s3 &&

+test -f $s1 ?!AMP?!

+test $(cat $s2) = tree2path1 &&

+test $(cat $s3) = tree3path1 )

+# LINT: start of subshell chained to preceding command

+mkdir sub && (

+ cd sub &&

+ foo the bar

+ nuff said

+) &&

+

+# LINT: preceding command pipes to subshell on same line

+cut "-d " -f actual | (read s1 s2 s3 &&

+test -f $s1

+test $(cat $s2) = tree2path1 &&

+# LINT: closing subshell ")" correctly detected on same line as "$(...)"

+test $(cat $s3) = tree3path1)

+OUT=$(( ( large_git 1 >& 3 ) | : ) 3 >& 1) &&

+test_match_signal 13 "$OUT"

+# LINT: subshell nested in subshell nested in command substitution

+OUT=$( ((large_git 1>&3) | :) 3>&1 ) &&

+test_match_signal 13 "$OUT"

+ fi ?!LOOP?!

+run_sub_test_lib_test_err run-inv-range-start "--run invalid range start" --run="a-5" <<-EOF &&

+check_sub_test_lib_test_err run-inv-range-start <<-EOF_OUT 3 <<-EOF_ERR

+run_sub_test_lib_test_err run-inv-range-start \

+ "--run invalid range start" \

+ --run="a-5" <<-\EOF &&

+test_expect_success "passing test #1" "true"

+test_done

+EOF

+check_sub_test_lib_test_err run-inv-range-start \

+ <<-\EOF_OUT 3<<-EOF_ERR

+> FATAL: Unexpected exit with code 1

+EOF_OUT

+> error: --run: invalid non-numeric in range start: ${SQ}a-5${SQ}

+EOF_ERR

+echo 'fatal: reword option of --fixup is mutually exclusive with' '--patch/--interactive/--all/--include/--only' > expect &&

+test_must_fail git commit --fixup=reword:HEAD~ $1 2 > actual &&

+test_cmp expect actual

+# LINT: line-splice within DQ-string

+'"

+echo 'fatal: reword option of --fixup is mutually exclusive with'\

+ '--patch/--interactive/--all/--include/--only' >expect &&

+test_must_fail git commit --fixup=reword:HEAD~ $1 2>actual &&

+test_cmp expect actual

+"'

+grep "^ ! [rejected][ ]*$BRANCH -> $BRANCH (non-fast-forward)$" out &&

+

+grep "^\.git$" output.txt &&

+

+

+(

+ cd client$version &&

+ GIT_TEST_PROTOCOL_VERSION=$version git fetch-pack --no-progress .. $(cat ../input)

+) > output &&

+ cut -d ' ' -f 2 < output | sort > actual &&

+ test_cmp expect actual

+# LINT: regex dollar-sign eol anchor in double-quoted string not special

+grep "^ ! \[rejected\][ ]*$BRANCH -> $BRANCH (non-fast-forward)$" out &&

+

+# LINT: escaped "$" not mistaken for variable expansion

+grep "^\\.git\$" output.txt &&

+

+'"

+(

+ cd client$version &&

+# LINT: escaped dollar-sign in double-quoted test body

+ GIT_TEST_PROTOCOL_VERSION=$version git fetch-pack --no-progress .. \$(cat ../input)

+) >output &&

+ cut -d ' ' -f 2 <output | sort >actual &&

+ test_cmp expect actual

+"'

+git ls-tree $tree path > current &&

+cat > expected <<EOF &&

+test_output

+git ls-tree $tree path >current &&

+# LINT: empty here-doc

+cat >expected <<\EOF &&

+EOF

+test_output

+if ! condition ; then echo nope ; else yep ; fi &&

+test_prerequisite !MINGW &&

+mail uucp!address &&

+echo !whatever!

+# LINT: "! word" is two tokens

+if ! condition; then echo nope; else yep; fi &&

+# LINT: "!word" is single token, not two tokens "!" and "word"

+test_prerequisite !MINGW &&

+# LINT: "word!word" is single token, not three tokens "word", "!", and "word"

+mail uucp!address &&

+# LINT: "!word!" is single token, not three tokens "!", "word", and "!"

+echo !whatever!

+for it

+do

+ path=$(expr "$it" : ( [^:]*) ) &&

+ git update-index --add "$path" || exit

+done

+# LINT: for-loop lacking optional "in [word...]" before "do"

+for it

+do

+ path=$(expr "$it" : '\([^:]*\)') &&

+ git update-index --add "$path" || exit

+done

+ cat <<-EOF ?!LOOP?!

+ cat $i ?!LOOP?!

+sha1_file ( ) {

+ echo "$*" | sed "s#..#.git/objects/&/#"

+} &&

+

+remove_object ( ) {

+ file=$(sha1_file "$*") &&

+ test -e "$file" ?!AMP?!

+ rm -f "$file"

+} ?!AMP?!

+

+sha1_file arg && remove_object arg

+# LINT: "()" in function definition not mistaken for subshell

+sha1_file() {

+ echo "$*" | sed "s#..#.git/objects/&/#"

+} &&

+

+# LINT: broken &&-chain in function and after function

+remove_object() {

+ file=$(sha1_file "$*") &&

+ test -e "$file"

+ rm -f "$file"

+}

+

+sha1_file arg && remove_object arg

+cat > expect <<-EOF &&

+

+cat > expect <<-EOF ?!AMP?!

+

+cleanup

+# LINT: whitespace between operator "<<-" and tag legal

+cat >expect <<- EOF &&

+header: 43475048 1 $(test_oid oid_version) $NUM_CHUNKS 0

+num_commits: $1

+chunks: oid_fanout oid_lookup commit_metadata generation_data bloom_indexes bloom_data

+EOF

+

+# LINT: not an indented here-doc; just a plain here-doc with tag named "-EOF"

+cat >expect << -EOF

+this is not indented

+-EOF

+

+cleanup

+ cat <<-TXT && echo "multi-line

+ string" ?!AMP?!

+if bob &&

+ marcia ||

+ kevin

+then

+ echo "nomads" ?!AMP?!

+ echo "for sure"

+fi

+# LINT: "if" condition split across multiple lines at "&&" or "||"

+if bob &&

+ marcia ||

+ kevin

+then

+ echo "nomads"

+ echo "for sure"

+fi

+ echo "err"

+# LINT: missing "&&" on "echo" okay since "exit 1" signals error explicitly

+git init r1 &&

+for n in 1 2 3 4 5

+do

+ echo "This is file: $n" > r1/file.$n &&

+ git -C r1 add file.$n &&

+ git -C r1 commit -m "$n" || return 1

+done &&

+

+git init r2 &&

+for n in 1000 10000

+do

+ printf "%"$n"s" X > r2/large.$n &&

+ git -C r2 add large.$n &&

+ git -C r2 commit -m "$n" ?!LOOP?!

+done

+git init r1 &&

+# LINT: loop handles failure explicitly with "|| return 1"

+for n in 1 2 3 4 5

+do

+ echo "This is file: $n" > r1/file.$n &&

+ git -C r1 add file.$n &&

+ git -C r1 commit -m "$n" || return 1

+done &&

+

+git init r2 &&

+# LINT: loop fails to handle failure explicitly with "|| return 1"

+for n in 1000 10000

+do

+ printf "%"$n"s" X > r2/large.$n &&

+ git -C r2 add large.$n &&

+ git -C r2 commit -m "$n"

+done

+( while test $i -le $blobcount

+do

+ printf "Generating blob $i/$blobcount\r" >& 2 &&

+ printf "blob\nmark :$i\ndata $blobsize\n" &&

+

+ printf "%-${blobsize}s" $i &&

+ echo "M 100644 :$i $i" >> commit &&

+ i=$(($i+1)) ||

+ echo $? > exit-status

+done &&

+echo "commit refs/heads/main" &&

+echo "author A U Thor <author@email.com> 123456789 +0000" &&

+echo "committer C O Mitter <committer@email.com> 123456789 +0000" &&

+echo "data 5" &&

+echo ">2gb" &&

+cat commit ) |

+git fast-import --big-file-threshold=2 &&

+test ! -f exit-status

+# LINT: "$?" handled explicitly within loop body

+(while test $i -le $blobcount

+ do

+ printf "Generating blob $i/$blobcount\r" >&2 &&

+ printf "blob\nmark :$i\ndata $blobsize\n" &&

+ #test-tool genrandom $i $blobsize &&

+ printf "%-${blobsize}s" $i &&

+ echo "M 100644 :$i $i" >> commit &&

+ i=$(($i+1)) ||

+ echo $? > exit-status

+ done &&

+ echo "commit refs/heads/main" &&

+ echo "author A U Thor <author@email.com> 123456789 +0000" &&

+ echo "committer C O Mitter <committer@email.com> 123456789 +0000" &&

+ echo "data 5" &&

+ echo ">2gb" &&

+ cat commit) |

+git fast-import --big-file-threshold=2 &&

+test ! -f exit-status

+ echo "glup" ?!LOOP?!

+(

+ git rev-list --objects --no-object-names base..loose |

+ while read oid

+ do

+ path="$objdir/$(test_oid_to_path "$oid")" &&

+ printf "%s %d\n" "$oid" "$(test-tool chmtime --get "$path")" ||

+ echo "object list generation failed for $oid"

+ done |

+ sort -k1

+) >expect &&

+(

+ git rev-list --objects --no-object-names base..loose |

+ while read oid

+ do

+# LINT: "|| echo" signals failure in loop upstream of a pipe

+ path="$objdir/$(test_oid_to_path "$oid")" &&

+ printf "%s %d\n" "$oid" "$(test-tool chmtime --get "$path")" ||

+ echo "object list generation failed for $oid"

+ done |

+ sort -k1

+) >expect &&

+ x="line 1

+ line 2

+ line 3" &&

+ y="line 1

+ line2" ?!AMP?!

+ echo "xyz" "abc

+ def

+ ghi" &&

+for i in 0 1 2 3 4 5 6 7 8 9 ;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9 ;

+ do

+ echo "$i$j" > "path$i$j" ?!LOOP?!

+ done ?!LOOP?!

+done &&

+

+for i in 0 1 2 3 4 5 6 7 8 9 ;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9 ;

+ do

+ echo "$i$j" > "path$i$j" || return 1

+ done

+done &&

+

+for i in 0 1 2 3 4 5 6 7 8 9 ;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9 ;

+ do

+ echo "$i$j" > "path$i$j" ?!LOOP?!

+ done || return 1

+done &&

+

+for i in 0 1 2 3 4 5 6 7 8 9 ;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9 ;

+ do

+ echo "$i$j" > "path$i$j" || return 1

+ done || return 1

+done

+# LINT: neither loop handles failure explicitly with "|| return 1"

+for i in 0 1 2 3 4 5 6 7 8 9;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9;

+ do

+ echo "$i$j" >"path$i$j"

+ done

+done &&

+

+# LINT: inner loop handles failure explicitly with "|| return 1"

+for i in 0 1 2 3 4 5 6 7 8 9;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9;

+ do

+ echo "$i$j" >"path$i$j" || return 1

+ done

+done &&

+

+# LINT: outer loop handles failure explicitly with "|| return 1"

+for i in 0 1 2 3 4 5 6 7 8 9;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9;

+ do

+ echo "$i$j" >"path$i$j"

+ done || return 1

+done &&

+

+# LINT: inner & outer loops handles failure explicitly with "|| return 1"

+for i in 0 1 2 3 4 5 6 7 8 9;

+do

+ for j in 0 1 2 3 4 5 6 7 8 9;

+ do

+ echo "$i$j" >"path$i$j" || return 1

+ done || return 1

+done

+ echo a ?!AMP?!

+git init dir-rename-and-content &&

+(

+ cd dir-rename-and-content &&

+ test_write_lines 1 2 3 4 5 >foo &&

+ mkdir olddir &&

+ for i in a b c; do echo $i >olddir/$i; ?!LOOP?! done ?!AMP?!

+ git add foo olddir &&

+ git commit -m "original" &&

+)

+git init dir-rename-and-content &&

+(

+ cd dir-rename-and-content &&

+ test_write_lines 1 2 3 4 5 >foo &&

+ mkdir olddir &&

+# LINT: one-liner for-loop missing "|| exit"; also broken &&-chain

+ for i in a b c; do echo $i >olddir/$i; done

+ git add foo olddir &&

+ git commit -m "original" &&

+)

+while test $i -lt $((num - 5))

+do

+ git notes add -m "notes for commit$i" HEAD~$i || return 1

+ i=$((i + 1))

+done

+while test $i -lt $((num - 5))

+do

+# LINT: "|| return {n}" valid loop escape outside subshell; no "&&" needed

+ git notes add -m "notes for commit$i" HEAD~$i || return 1

+ i=$((i + 1))

+done

+ echo; ?!LOOP?!

+perl -e '

+ defined($_ = -s $_) or die for @ARGV;

+ exit 1 if $ARGV[0] <= $ARGV[1];

+' test-2-$packname_2.pack test-3-$packname_3.pack

+# LINT: SQ-string Perl code fragment within SQ-string

+perl -e '\''

+ defined($_ = -s $_) or die for @ARGV;

+ exit 1 if $ARGV[0] <= $ARGV[1];

+'\'' test-2-$packname_2.pack test-3-$packname_3.pack

+ chks="sub1

+sub2

+sub3

+sub4" &&

+ chkms="main-sub1

+main-sub2

+main-sub3

+main-sub4" &&

+ check_equal "$subfiles" "$chkms

+$chks"

+git config filter.rot13.smudge ./rot13.sh &&

+git config filter.rot13.clean ./rot13.sh &&

+

+{

+ echo "*.t filter=rot13" ?!AMP?!

+ echo "*.i ident"

+} > .gitattributes &&

+

+{

+ echo a b c d e f g h i j k l m ?!AMP?!

+ echo n o p q r s t u v w x y z ?!AMP?!

+ echo '$Id$'

+} > test &&

+cat test > test.t &&

+cat test > test.o &&

+cat test > test.i &&

+git add test test.t test.i &&

+rm -f test test.t test.i &&

+git checkout -- test test.t test.i &&

+

+echo "content-test2" > test2.o &&

+echo "content-test3 - filename with special characters" > "test3 'sq',$x=.o" ?!AMP?!

+

+downstream_url_for_sed=$(

+ printf "%sn" "$downstream_url" |

+ sed -e 's/\/\\/g' -e 's/[[/.*^$]/\&/g'

+)

+# LINT: single token; composite of multiple strings

+git config filter.rot13.smudge ./rot13.sh &&

+git config filter.rot13.clean ./rot13.sh &&

+

+{

+ echo "*.t filter=rot13"

+ echo "*.i ident"

+} >.gitattributes &&

+

+{

+ echo a b c d e f g h i j k l m

+ echo n o p q r s t u v w x y z

+# LINT: exit/enter string context and escaped-quote outside of string

+ echo '\''$Id$'\''

+} >test &&

+cat test >test.t &&

+cat test >test.o &&

+cat test >test.i &&

+git add test test.t test.i &&

+rm -f test test.t test.i &&

+git checkout -- test test.t test.i &&

+

+echo "content-test2" >test2.o &&

+# LINT: exit/enter string context and escaped-quote outside of string

+echo "content-test3 - filename with special characters" >"test3 '\''sq'\'',\$x=.o"

+

+# LINT: single token; composite of multiple strings

+downstream_url_for_sed=$(

+ printf "%s\n" "$downstream_url" |

+# LINT: exit/enter string context; "&" inside string not command terminator

+ sed -e '\''s/\\/\\\\/g'\'' -e '\''s/[[/.*^$]/\\&/g'\''

+)

+ cat <<-EOF ?!LOOP?!

+ cat bar ?!LOOP?!

+ clear_bloom_key(&key);

+ free(filter.data);

+static int iterate_cb(const char *var, const char *value, void *data UNUSED)

+ * Usage: test-tool crontab <file> -l|<input>

+ * Otherwise, copy the contents of <input> into <file>.

+ if (argc != 3)

+ usage("test-tool crontab <file> -l|<input>");

+

+ if (!strcmp(argv[2], "-l")) {

+ } else {

+ from = xfopen(argv[2], "r");

+ to = xfopen(argv[1], "w");

+ }

+ fclose(from);

+ if (to != stdout)

+ void *from_buf = NULL, *data_buf = NULL, *out_buf = NULL;

+ int ret = 1;

+ goto cleanup;

+ goto cleanup;

+ goto cleanup;

+ goto cleanup;

+ goto cleanup;

+ ret = 0;

+cleanup:

+ free(from_buf);

+ free(data_buf);

+ free(out_buf);

+

+ return ret;

+ int ret;

+

+ ret = dump_cache_tree(active_cache_tree, another, "");

+ cache_tree_free(&another);

+

+ return ret;

+ free(buffer);

+ make_obj1(0);

+ make_arr1(0);

+

+

+ jw_release(&obj1);

+ jw_release(&arr1);

+

+ jw_release(&obj1);

+ jw_release(&arr1);

+#define t(v) do { make_##v(0); cmp(#v, &v, expect_##v); jw_release(&v); } while (0)

+#define p(v) do { make_##v(1); cmp(#v, &v, pretty_##v); jw_release(&v); } while (0)

+ jw_release(&jw);

+DEFINE_LIST_SORT(static, sort_lines, struct line, next);

+static int compare_strings(const struct line *x, const struct line *y)

+ struct line *lines;

+ struct line **tail = &lines;

+ struct mem_pool lines_pool;

+ char *p;

+

+ strbuf_read(&sb, 0, 0);

+

+ /*

+ * Split by newline, but don't create an item

+ * for the empty string after the last separator.

+ */

+ if (sb.len && sb.buf[sb.len - 1] == '\n')

+ strbuf_setlen(&sb, sb.len - 1);

+

+ mem_pool_init(&lines_pool, 0);

+ p = sb.buf;

+ for (;;) {

+ char *eol = strchr(p, '\n');

+ struct line *line = mem_pool_alloc(&lines_pool, sizeof(*line));

+ line->text = p;

+ *tail = line;

+ tail = &line->next;

+ if (!eol)

+ break;

+ *eol = '\0';

+ p = eol + 1;

+ *tail = NULL;

+ sort_lines(&lines, compare_strings);

+DEFINE_LIST_SORT_DEBUG(static, sort_numbers, struct number, next,

+ stats.get_next++, stats.set_next++);

+static int compare_numbers(const struct number *an, const struct number *bn)

+ sort_numbers(&list, compare_numbers);

+

+static void print_args(int argc, const char **argv)

+{

+ int i;

+ for (i = 0; i < argc; i++)

+ printf("arg %02d: %s\n", i, argv[i]);

+}

+

+static int parse_options_flags__cmd(int argc, const char **argv,

+ enum parse_opt_flags test_flags)

+{

+ const char *usage[] = {

+ "<...> cmd [options]",

+ NULL

+ };

+ int opt = 0;

+ const struct option options[] = {

+ OPT_INTEGER('o', "opt", &opt, "an integer option"),

+ OPT_END()

+ };

+

+ argc = parse_options(argc, argv, NULL, options, usage, test_flags);

+

+ printf("opt: %d\n", opt);

+ print_args(argc, argv);

+

+ return 0;

+}

+

+static enum parse_opt_flags test_flags = 0;

+static const struct option test_flag_options[] = {

+ OPT_GROUP("flag-options:"),

+ OPT_BIT(0, "keep-dashdash", &test_flags,

+ "pass PARSE_OPT_KEEP_DASHDASH to parse_options()",

+ PARSE_OPT_KEEP_DASHDASH),

+ OPT_BIT(0, "stop-at-non-option", &test_flags,

+ "pass PARSE_OPT_STOP_AT_NON_OPTION to parse_options()",

+ PARSE_OPT_STOP_AT_NON_OPTION),

+ OPT_BIT(0, "keep-argv0", &test_flags,

+ "pass PARSE_OPT_KEEP_ARGV0 to parse_options()",

+ PARSE_OPT_KEEP_ARGV0),

+ OPT_BIT(0, "keep-unknown-opt", &test_flags,

+ "pass PARSE_OPT_KEEP_UNKNOWN_OPT to parse_options()",

+ PARSE_OPT_KEEP_UNKNOWN_OPT),

+ OPT_BIT(0, "no-internal-help", &test_flags,

+ "pass PARSE_OPT_NO_INTERNAL_HELP to parse_options()",

+ PARSE_OPT_NO_INTERNAL_HELP),

+ OPT_BIT(0, "subcommand-optional", &test_flags,

+ "pass PARSE_OPT_SUBCOMMAND_OPTIONAL to parse_options()",

+ PARSE_OPT_SUBCOMMAND_OPTIONAL),

+ OPT_END()

+};

+

+int cmd__parse_options_flags(int argc, const char **argv)

+{

+ const char *usage[] = {

+ "test-tool parse-options-flags [flag-options] cmd [options]",

+ NULL

+ };

+

+ argc = parse_options(argc, argv, NULL, test_flag_options, usage,

+ PARSE_OPT_STOP_AT_NON_OPTION);

+

+ if (!argc || strcmp(argv[0], "cmd")) {

+ error("'cmd' is mandatory");

+ usage_with_options(usage, test_flag_options);

+ }

+

+ return parse_options_flags__cmd(argc, argv, test_flags);

+}

+

+static int subcmd_one(int argc, const char **argv, const char *prefix)

+{

+ printf("fn: subcmd_one\n");

+ print_args(argc, argv);

+ return 0;

+}

+

+static int subcmd_two(int argc, const char **argv, const char *prefix)

+{

+ printf("fn: subcmd_two\n");

+ print_args(argc, argv);

+ return 0;

+}

+

+static int parse_subcommand__cmd(int argc, const char **argv,

+ enum parse_opt_flags test_flags)

+{

+ const char *usage[] = {

+ "<...> cmd subcmd-one",

+ "<...> cmd subcmd-two",

+ NULL

+ };

+ parse_opt_subcommand_fn *fn = NULL;

+ int opt = 0;

+ struct option options[] = {

+ OPT_SUBCOMMAND("subcmd-one", &fn, subcmd_one),

+ OPT_SUBCOMMAND("subcmd-two", &fn, subcmd_two),

+ OPT_INTEGER('o', "opt", &opt, "an integer option"),

+ OPT_END()

+ };

+

+ if (test_flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)

+ fn = subcmd_one;

+ argc = parse_options(argc, argv, NULL, options, usage, test_flags);

+

+ printf("opt: %d\n", opt);

+

+ return fn(argc, argv, NULL);

+}

+

+int cmd__parse_subcommand(int argc, const char **argv)

+{

+ const char *usage[] = {

+ "test-tool parse-subcommand [flag-options] cmd <subcommand>",

+ NULL

+ };

+

+ argc = parse_options(argc, argv, NULL, test_flag_options, usage,

+ PARSE_OPT_STOP_AT_NON_OPTION);

+

+ if (!argc || strcmp(argv[0], "cmd")) {

+ error("'cmd' is mandatory");

+ usage_with_options(usage, test_flag_options);

+ }

+

+ return parse_subcommand__cmd(argc, argv, test_flags);

+}

+ puts(rv ? "++failed++" : buf);

+ free(buf);

+ char *pfx = prefix_path(prefix, prefix_len, argv[3]);

+

+ puts(pfx);

+ free(pfx);

+ free(prefix);

+ free_worktrees(worktrees);

+ int flags, void *cb_data UNUSED)

+ int tz, const char *msg, void *cb_data UNUSED)

+ regfree(&r);

+ goto cleanup;

+ goto cleanup;

+cleanup:

+ regfree(&r);

+ return ret;

+/*

+ * Example implementation for the Git filter protocol version 2

+ * See Documentation/gitattributes.txt, section "Filter Protocol"

+ *

+ * Usage: test-tool rot13-filter [--always-delay] --log=<path> <capabilities>

+ *

+ * Log path defines a debug log file that the script writes to. The

+ * subsequent arguments define a list of supported protocol capabilities

+ * ("clean", "smudge", etc).

+ *

+ * When --always-delay is given all pathnames with the "can-delay" flag

+ * that don't appear on the list bellow are delayed with a count of 1

+ * (see more below).

+ *

+ * This implementation supports special test cases:

+ * (1) If data with the pathname "clean-write-fail.r" is processed with

+ * a "clean" operation then the write operation will die.

+ * (2) If data with the pathname "smudge-write-fail.r" is processed with

+ * a "smudge" operation then the write operation will die.

+ * (3) If data with the pathname "error.r" is processed with any

+ * operation then the filter signals that it cannot or does not want

+ * to process the file.

+ * (4) If data with the pathname "abort.r" is processed with any

+ * operation then the filter signals that it cannot or does not want

+ * to process the file and any file after that is processed with the

+ * same command.

+ * (5) If data with a pathname that is a key in the delay hash is

+ * requested (e.g. "test-delay10.a") then the filter responds with

+ * a "delay" status and sets the "requested" field in the delay hash.

+ * The filter will signal the availability of this object after

+ * "count" (field in delay hash) "list_available_blobs" commands.

+ * (6) If data with the pathname "missing-delay.a" is processed that the

+ * filter will drop the path from the "list_available_blobs" response.

+ * (7) If data with the pathname "invalid-delay.a" is processed that the

+ * filter will add the path "unfiltered" which was not delayed before

+ * to the "list_available_blobs" response.

+ */

+

+#include "test-tool.h"

+#include "pkt-line.h"

+#include "string-list.h"

+#include "strmap.h"

+#include "parse-options.h"

+

+static FILE *logfile;

+static int always_delay, has_clean_cap, has_smudge_cap;

+static struct strmap delay = STRMAP_INIT;

+

+static inline const char *str_or_null(const char *str)

+{

+ return str ? str : "(null)";

+}

+

+static char *rot13(char *str)

+{

+ char *c;

+ for (c = str; *c; c++)

+ if (isalpha(*c))

+ *c += tolower(*c) < 'n' ? 13 : -13;

+ return str;

+}

+

+static char *get_value(char *buf, const char *key)

+{

+ const char *orig_buf = buf;

+ if (!buf ||

+ !skip_prefix((const char *)buf, key, (const char **)&buf) ||

+ !skip_prefix((const char *)buf, "=", (const char **)&buf) ||

+ !*buf)

+ die("expected key '%s', got '%s'", key, str_or_null(orig_buf));

+ return buf;

+}

+

+/*

+ * Read a text packet, expecting that it is in the form "key=value" for

+ * the given key. An EOF does not trigger any error and is reported

+ * back to the caller with NULL. Die if the "key" part of "key=value" does

+ * not match the given key, or the value part is empty.

+ */

+static char *packet_key_val_read(const char *key)

+{

+ char *buf;

+ if (packet_read_line_gently(0, NULL, &buf) < 0)

+ return NULL;

+ return xstrdup(get_value(buf, key));

+}

+

+static inline void assert_remote_capability(struct strset *caps, const char *cap)

+{

+ if (!strset_contains(caps, cap))

+ die("required '%s' capability not available from remote", cap);

+}

+

+static void read_capabilities(struct strset *remote_caps)

+{

+ for (;;) {

+ char *buf = packet_read_line(0, NULL);

+ if (!buf)

+ break;

+ strset_add(remote_caps, get_value(buf, "capability"));

+ }

+

+ assert_remote_capability(remote_caps, "clean");

+ assert_remote_capability(remote_caps, "smudge");

+ assert_remote_capability(remote_caps, "delay");

+}

+

+static void check_and_write_capabilities(struct strset *remote_caps,

+ const char **caps, int nr_caps)

+{

+ int i;

+ for (i = 0; i < nr_caps; i++) {

+ if (!strset_contains(remote_caps, caps[i]))

+ die("our capability '%s' is not available from remote",

+ caps[i]);

+ packet_write_fmt(1, "capability=%s\n", caps[i]);

+ }

+ packet_flush(1);

+}

+

+struct delay_entry {

+ int requested, count;

+ char *output;

+};

+

+static void free_delay_entries(void)

+{

+ struct hashmap_iter iter;

+ struct strmap_entry *ent;

+

+ strmap_for_each_entry(&delay, &iter, ent) {

+ struct delay_entry *delay_entry = ent->value;

+ free(delay_entry->output);

+ free(delay_entry);

+ }

+ strmap_clear(&delay, 0);

+}

+

+static void add_delay_entry(char *pathname, int count, int requested)

+{

+ struct delay_entry *entry = xcalloc(1, sizeof(*entry));

+ entry->count = count;

+ entry->requested = requested;

+ if (strmap_put(&delay, pathname, entry))

+ BUG("adding the same path twice to delay hash?");

+}

+

+static void reply_list_available_blobs_cmd(void)

+{

+ struct hashmap_iter iter;

+ struct strmap_entry *ent;

+ struct string_list_item *str_item;

+ struct string_list paths = STRING_LIST_INIT_NODUP;

+

+ /* flush */

+ if (packet_read_line(0, NULL))

+ die("bad list_available_blobs end");

+

+ strmap_for_each_entry(&delay, &iter, ent) {

+ struct delay_entry *delay_entry = ent->value;

+ if (!delay_entry->requested)

+ continue;

+ delay_entry->count--;

+ if (!strcmp(ent->key, "invalid-delay.a")) {

+ /* Send Git a pathname that was not delayed earlier */

+ packet_write_fmt(1, "pathname=unfiltered");

+ }

+ if (!strcmp(ent->key, "missing-delay.a")) {

+ /* Do not signal Git that this file is available */

+ } else if (!delay_entry->count) {

+ string_list_append(&paths, ent->key);

+ packet_write_fmt(1, "pathname=%s", ent->key);

+ }

+ }

+

+ /* Print paths in sorted order. */

+ string_list_sort(&paths);

+ for_each_string_list_item(str_item, &paths)

+ fprintf(logfile, " %s", str_item->string);

+ string_list_clear(&paths, 0);

+

+ packet_flush(1);

+

+ fprintf(logfile, " [OK]\n");

+ packet_write_fmt(1, "status=success");

+ packet_flush(1);

+}

+

+static void command_loop(void)

+{

+ for (;;) {

+ char *buf, *output;

+ char *pathname;

+ struct delay_entry *entry;

+ struct strbuf input = STRBUF_INIT;

+ char *command = packet_key_val_read("command");

+

+ if (!command) {

+ fprintf(logfile, "STOP\n");

+ break;

+ }

+ fprintf(logfile, "IN: %s", command);

+

+ if (!strcmp(command, "list_available_blobs")) {

+ reply_list_available_blobs_cmd();

+ free(command);

+ continue;

+ }

+

+ pathname = packet_key_val_read("pathname");

+ if (!pathname)

+ die("unexpected EOF while expecting pathname");

+ fprintf(logfile, " %s", pathname);

+

+ /* Read until flush */

+ while ((buf = packet_read_line(0, NULL))) {

+ if (!strcmp(buf, "can-delay=1")) {

+ entry = strmap_get(&delay, pathname);

+ if (entry && !entry->requested)

+ entry->requested = 1;

+ else if (!entry && always_delay)

+ add_delay_entry(pathname, 1, 1);

+ } else if (starts_with(buf, "ref=") ||

+ starts_with(buf, "treeish=") ||

+ starts_with(buf, "blob=")) {

+ fprintf(logfile, " %s", buf);

+ } else {

+ /*

+ * In general, filters need to be graceful about

+ * new metadata, since it's documented that we

+ * can pass any key-value pairs, but for tests,

+ * let's be a little stricter.

+ */

+ die("Unknown message '%s'", buf);

+ }

+ }

+

+ read_packetized_to_strbuf(0, &input, 0);

+ fprintf(logfile, " %"PRIuMAX" [OK] -- ", (uintmax_t)input.len);

+

+ entry = strmap_get(&delay, pathname);

+ if (entry && entry->output) {

+ output = entry->output;

+ } else if (!strcmp(pathname, "error.r") || !strcmp(pathname, "abort.r")) {

+ output = "";

+ } else if (!strcmp(command, "clean") && has_clean_cap) {

+ output = rot13(input.buf);

+ } else if (!strcmp(command, "smudge") && has_smudge_cap) {

+ output = rot13(input.buf);

+ } else {

+ die("bad command '%s'", command);

+ }

+

+ if (!strcmp(pathname, "error.r")) {

+ fprintf(logfile, "[ERROR]\n");

+ packet_write_fmt(1, "status=error");

+ packet_flush(1);

+ } else if (!strcmp(pathname, "abort.r")) {

+ fprintf(logfile, "[ABORT]\n");

+ packet_write_fmt(1, "status=abort");

+ packet_flush(1);

+ } else if (!strcmp(command, "smudge") &&

+ (entry = strmap_get(&delay, pathname)) &&

+ entry->requested == 1) {

+ fprintf(logfile, "[DELAYED]\n");

+ packet_write_fmt(1, "status=delayed");

+ packet_flush(1);

+ entry->requested = 2;

+ if (entry->output != output) {

+ free(entry->output);

+ entry->output = xstrdup(output);

+ }

+ } else {

+ int i, nr_packets = 0;

+ size_t output_len;

+ const char *p;

+ packet_write_fmt(1, "status=success");

+ packet_flush(1);

+

+ if (skip_prefix(pathname, command, &p) &&

+ !strcmp(p, "-write-fail.r")) {

+ fprintf(logfile, "[WRITE FAIL]\n");

+ die("%s write error", command);

+ }

+

+ output_len = strlen(output);

+ fprintf(logfile, "OUT: %"PRIuMAX" ", (uintmax_t)output_len);

+

+ if (write_packetized_from_buf_no_flush_count(output,

+ output_len, 1, &nr_packets))

+ die("failed to write buffer to stdout");

+ packet_flush(1);

+

+ for (i = 0; i < nr_packets; i++)

+ fprintf(logfile, ".");

+ fprintf(logfile, " [OK]\n");

+

+ packet_flush(1);

+ }

+ free(pathname);

+ strbuf_release(&input);

+ free(command);

+ }

+}

+

+static void packet_initialize(void)

+{

+ char *pkt_buf = packet_read_line(0, NULL);

+

+ if (!pkt_buf || strcmp(pkt_buf, "git-filter-client"))

+ die("bad initialize: '%s'", str_or_null(pkt_buf));

+

+ pkt_buf = packet_read_line(0, NULL);

+ if (!pkt_buf || strcmp(pkt_buf, "version=2"))

+ die("bad version: '%s'", str_or_null(pkt_buf));

+

+ pkt_buf = packet_read_line(0, NULL);

+ if (pkt_buf)

+ die("bad version end: '%s'", pkt_buf);

+

+ packet_write_fmt(1, "git-filter-server");

+ packet_write_fmt(1, "version=2");

+ packet_flush(1);

+}

+

+static const char *rot13_usage[] = {

+ "test-tool rot13-filter [--always-delay] --log=<path> <capabilities>",

+ NULL

+};

+

+int cmd__rot13_filter(int argc, const char **argv)

+{

+ int i, nr_caps;

+ struct strset remote_caps = STRSET_INIT;

+ const char *log_path = NULL;

+

+ struct option options[] = {

+ OPT_BOOL(0, "always-delay", &always_delay,

+ "delay all paths with the can-delay flag"),

+ OPT_STRING(0, "log", &log_path, "path",

+ "path to the debug log file"),

+ OPT_END()

+ };

+ nr_caps = parse_options(argc, argv, NULL, options, rot13_usage,

+ PARSE_OPT_STOP_AT_NON_OPTION);

+

+ if (!log_path || !nr_caps)

+ usage_with_options(rot13_usage, options);

+

+ logfile = fopen(log_path, "a");

+ if (!logfile)

+ die_errno("failed to open log file");

+

+ for (i = 0; i < nr_caps; i++) {

+ if (!strcmp(argv[i], "smudge"))

+ has_smudge_cap = 1;

+ if (!strcmp(argv[i], "clean"))

+ has_clean_cap = 1;

+ }

+

+ add_delay_entry("test-delay10.a", 1, 0);

+ add_delay_entry("test-delay11.a", 1, 0);

+ add_delay_entry("test-delay20.a", 2, 0);

+ add_delay_entry("test-delay10.b", 1, 0);

+ add_delay_entry("missing-delay.a", 1, 0);

+ add_delay_entry("invalid-delay.a", 1, 0);

+

+ fprintf(logfile, "START\n");

+ packet_initialize();

+

+ read_capabilities(&remote_caps);

+ check_and_write_capabilities(&remote_caps, argv, nr_caps);

+ fprintf(logfile, "init handshake complete\n");

+ strset_clear(&remote_caps);

+

+ command_loop();

+

+ if (fclose(logfile))

+ die_errno("error closing logfile");

+ free_delay_entries();

+ return 0;

+}

+ cache_tree_free(&active_cache_tree);

+ PARSE_OPT_KEEP_UNKNOWN_OPT);

+ printf("Submodule name: '%s' for path '%s'\n", submodule->name,

+ submodule->path);

+#include "test-tool.h"

+#include "test-tool-utils.h"

+#include "cache.h"

+#include "parse-options.h"

+#include "remote.h"

+#include "submodule-config.h"

+#include "submodule.h"

+

+#define TEST_TOOL_CHECK_NAME_USAGE \

+ "test-tool submodule check-name <name>"

+static const char *submodule_check_name_usage[] = {

+ TEST_TOOL_CHECK_NAME_USAGE,

+ NULL

+};

+

+#define TEST_TOOL_IS_ACTIVE_USAGE \

+ "test-tool submodule is-active <name>"

+static const char *submodule_is_active_usage[] = {

+ TEST_TOOL_IS_ACTIVE_USAGE,

+ NULL

+};

+

+#define TEST_TOOL_RESOLVE_RELATIVE_URL_USAGE \

+ "test-tool submodule resolve-relative-url <up_path> <remoteurl> <url>"

+static const char *submodule_resolve_relative_url_usage[] = {

+ TEST_TOOL_RESOLVE_RELATIVE_URL_USAGE,

+ NULL,

+};

+

+static const char *submodule_usage[] = {

+ TEST_TOOL_CHECK_NAME_USAGE,

+ TEST_TOOL_IS_ACTIVE_USAGE,

+ TEST_TOOL_RESOLVE_RELATIVE_URL_USAGE,

+ NULL

+};

+

+/*

+ * Exit non-zero if any of the submodule names given on the command line is

+ * invalid. If no names are given, filter stdin to print only valid names

+ * (which is primarily intended for testing).

+ */

+static int check_name(int argc, const char **argv)

+{

+ if (argc > 1) {

+ while (*++argv) {

+ if (check_submodule_name(*argv) < 0)

+ return 1;

+ }

+ } else {

+ struct strbuf buf = STRBUF_INIT;

+ while (strbuf_getline(&buf, stdin) != EOF) {

+ if (!check_submodule_name(buf.buf))

+ printf("%s\n", buf.buf);

+ }

+ strbuf_release(&buf);

+ }

+ return 0;

+}

+

+static int cmd__submodule_check_name(int argc, const char **argv)

+{

+ struct option options[] = {

+ OPT_END()

+ };

+ argc = parse_options(argc, argv, "test-tools", options,

+ submodule_check_name_usage, 0);

+ if (argc)

+ usage_with_options(submodule_check_name_usage, options);

+

+ return check_name(argc, argv);

+}

+

+static int cmd__submodule_is_active(int argc, const char **argv)

+{

+ struct option options[] = {

+ OPT_END()

+ };

+ argc = parse_options(argc, argv, "test-tools", options,

+ submodule_is_active_usage, 0);

+ if (argc != 1)

+ usage_with_options(submodule_is_active_usage, options);

+

+ setup_git_directory();

+

+ return !is_submodule_active(the_repository, argv[0]);

+}

+

+static int resolve_relative_url(int argc, const char **argv)

+{

+ char *remoteurl, *res;

+ const char *up_path, *url;

+

+ up_path = argv[0];

+ remoteurl = xstrdup(argv[1]);

+ url = argv[2];

+

+ if (!strcmp(up_path, "(null)"))

+ up_path = NULL;

+

+ res = relative_url(remoteurl, url, up_path);

+ puts(res);

+ free(res);

+ free(remoteurl);

+ return 0;

+}

+

+static int cmd__submodule_resolve_relative_url(int argc, const char **argv)

+{

+ struct option options[] = {

+ OPT_END()

+ };

+ argc = parse_options(argc, argv, "test-tools", options,

+ submodule_resolve_relative_url_usage, 0);

+ if (argc != 3)

+ usage_with_options(submodule_resolve_relative_url_usage, options);

+

+ return resolve_relative_url(argc, argv);

+}

+

+static struct test_cmd cmds[] = {

+ { "check-name", cmd__submodule_check_name },

+ { "is-active", cmd__submodule_is_active },

+ { "resolve-relative-url", cmd__submodule_resolve_relative_url},

+};

+

+int cmd__submodule(int argc, const char **argv)

+{

+ struct option options[] = {

+ OPT_END()

+ };

+ size_t i;

+

+ argc = parse_options(argc, argv, "test-tools", options, submodule_usage,

+ PARSE_OPT_STOP_AT_NON_OPTION);

+ if (argc < 1)

+ usage_with_options(submodule_usage, options);

+

+ for (i = 0; i < ARRAY_SIZE(cmds); i++)

+ if (!strcmp(cmds[i].name, argv[0]))

+ return cmds[i].fn(argc, argv);

+

+ usage_msg_optf("unknown subcommand '%s'", submodule_usage, options,

+ argv[0]);

+

+ return 0;

+}

+#ifndef TEST_TOOL_UTILS_H

+#define TEST_TOOL_UTILS_H

+

+struct test_cmd {

+ const char *name;

+ int (*fn)(int argc, const char **argv);

+};

+

+#endif

+#include "test-tool-utils.h"

+ { "parse-options-flags", cmd__parse_options_flags },

+ { "parse-subcommand", cmd__parse_subcommand },

+ { "rot13-filter", cmd__rot13_filter },

+ { "submodule", cmd__submodule },

+int cmd__parse_options_flags(int argc, const char **argv);

+int cmd__parse_subcommand(int argc, const char **argv);

+int cmd__rot13_filter(int argc, const char **argv);

+int cmd__submodule(int argc, const char **argv);

+ char *url1 = NULL, *url2 = NULL;

+ int ret = 0;

+ goto cleanup;

+ ret = (url1 && url2 && !strcmp(url1, url2)) ? 0 : 1;

+cleanup:

+ free(url1);

+ free(url2);

+ return ret;

+static int cmd__userdiff_config(const char *var, const char *value, void *cb UNUSED)

+ git multi-pack-index write --bitmap &&

+# Copyright (c) 2022 Ævar Arnfjörð Bjarmason

+

+test_lazy_prereq PERL_TEST_MORE '

+ perl -MTest::More -e 0

+'

+

+skip_all_if_no_Test_More () {

+ if ! test_have_prereq PERL

+ then

+ skip_all='skipping perl interface tests, perl not available'

+ test_done

+ fi

+

+ if ! test_have_prereq PERL_TEST_MORE

+ then

+ skip_all="Perl Test::More unavailable, skipping test"

+ test_done

+ fi

+}

+

+# usage: set_replace_editor <file>

+#

+# Replace the todo file with the exact contents of the given file.

+set_replace_editor () {

+ cat >script <<-\EOF &&

+ cat FILENAME >"$1"

+

+ echo 'rebase -i script after editing:'

+ cat "$1"

+ EOF

+

+ sed -e "s/FILENAME/$1/g" <script | write_script fake-editor.sh &&

+ test_set_editor "$(pwd)/fake-editor.sh"

+}

+ git clone --template= submodule_update_repo submodule_update &&

+ test_when_finished "rm -rf submodule_update/.git/info" &&

+ mkdir .git/info &&

+ rm -rf .git/modules/sub1/info &&

+ mkdir .git/modules/sub1/info &&