2010-01-10 14:11:22 +01:00
|
|
|
/*
|
|
|
|
|
* test-run-command.c: test run command API.
|
|
|
|
|
*
|
|
|
|
|
* (C) 2009 Ilari Liusvaara <ilari.liusvaara@elisanet.fi>
|
|
|
|
|
*
|
|
|
|
|
* This code is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
|
2018-03-24 08:44:55 +01:00
|
|
|
#include "test-tool.h"
|
2010-01-10 14:11:22 +01:00
|
|
|
#include "git-compat-util.h"
|
test-tool run-command: learn to run (parts of) the testsuite
Git for Windows jumps through hoops to provide a development environment
that allows to build Git and to run its test suite. To that end, an
entire MSYS2 system, including GNU make and GCC is offered as "the Git
for Windows SDK". It does come at a price: an initial download of said
SDK weighs in with several hundreds of megabytes, and the unpacked SDK
occupies ~2GB of disk space.
A much more native development environment on Windows is Visual Studio.
To help contributors use that environment, we already have a Makefile
target `vcxproj` that generates a commit with project files (and other
generated files), and Git for Windows' `vs/master` branch is
continuously re-generated using that target.
The idea is to allow building Git in Visual Studio, and to run
individual tests using a Portable Git.
The one missing thing is a way to run the entire test suite: neither
`make` nor `prove` are required to run Git, therefore Git for Windows
does not support those commands in the Portable Git.
To help with that, add a simple test helper that exercises the
`run_processes_parallel()` function to allow for running test scripts in
parallel (which is really necessary, especially on Windows, as Git's
test suite takes such a long time to run).
This will also come in handy for the upcoming change to our Azure
Pipeline: we will use this helper in a Portable Git to test the Visual
Studio build of Git.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-10-04 17:09:33 +02:00
|
|
|
#include "cache.h"
|
2010-01-10 14:11:22 +01:00
|
|
|
#include "run-command.h"
|
2020-07-28 22:23:39 +02:00
|
|
|
#include "strvec.h"
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
#include "strbuf.h"
|
test-tool run-command: learn to run (parts of) the testsuite
Git for Windows jumps through hoops to provide a development environment
that allows to build Git and to run its test suite. To that end, an
entire MSYS2 system, including GNU make and GCC is offered as "the Git
for Windows SDK". It does come at a price: an initial download of said
SDK weighs in with several hundreds of megabytes, and the unpacked SDK
occupies ~2GB of disk space.
A much more native development environment on Windows is Visual Studio.
To help contributors use that environment, we already have a Makefile
target `vcxproj` that generates a commit with project files (and other
generated files), and Git for Windows' `vs/master` branch is
continuously re-generated using that target.
The idea is to allow building Git in Visual Studio, and to run
individual tests using a Portable Git.
The one missing thing is a way to run the entire test suite: neither
`make` nor `prove` are required to run Git, therefore Git for Windows
does not support those commands in the Portable Git.
To help with that, add a simple test helper that exercises the
`run_processes_parallel()` function to allow for running test scripts in
parallel (which is really necessary, especially on Windows, as Git's
test suite takes such a long time to run).
This will also come in handy for the upcoming change to our Azure
Pipeline: we will use this helper in a Portable Git to test the Visual
Studio build of Git.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-10-04 17:09:33 +02:00
|
|
|
#include "parse-options.h"
|
|
|
|
|
#include "string-list.h"
|
|
|
|
|
#include "thread-utils.h"
|
|
|
|
|
#include "wildmatch.h"
|
2019-09-18 22:03:59 +02:00
|
|
|
#include "gettext.h"
|
|
|
|
|
#include "parse-options.h"
|
2010-01-10 14:11:22 +01:00
|
|
|
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
static int number_callbacks;
|
|
|
|
|
static int parallel_next(struct child_process *cp,
|
|
|
|
|
struct strbuf *err,
|
|
|
|
|
void *cb,
|
|
|
|
|
void **task_cb)
|
|
|
|
|
{
|
|
|
|
|
struct child_process *d = cb;
|
|
|
|
|
if (number_callbacks >= 4)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
argv_array_pushv(&cp->args, d->argv);
|
2016-07-30 19:36:23 +02:00
|
|
|
strbuf_addstr(err, "preloaded output of a child\n");
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
number_callbacks++;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int no_job(struct child_process *cp,
|
|
|
|
|
struct strbuf *err,
|
|
|
|
|
void *cb,
|
|
|
|
|
void **task_cb)
|
|
|
|
|
{
|
2016-07-30 19:36:23 +02:00
|
|
|
strbuf_addstr(err, "no further jobs available\n");
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int task_finished(int result,
|
|
|
|
|
struct strbuf *err,
|
|
|
|
|
void *pp_cb,
|
|
|
|
|
void *pp_task_cb)
|
|
|
|
|
{
|
2016-07-30 19:36:23 +02:00
|
|
|
strbuf_addstr(err, "asking for a quick stop\n");
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
test-tool run-command: learn to run (parts of) the testsuite
Git for Windows jumps through hoops to provide a development environment
that allows to build Git and to run its test suite. To that end, an
entire MSYS2 system, including GNU make and GCC is offered as "the Git
for Windows SDK". It does come at a price: an initial download of said
SDK weighs in with several hundreds of megabytes, and the unpacked SDK
occupies ~2GB of disk space.
A much more native development environment on Windows is Visual Studio.
To help contributors use that environment, we already have a Makefile
target `vcxproj` that generates a commit with project files (and other
generated files), and Git for Windows' `vs/master` branch is
continuously re-generated using that target.
The idea is to allow building Git in Visual Studio, and to run
individual tests using a Portable Git.
The one missing thing is a way to run the entire test suite: neither
`make` nor `prove` are required to run Git, therefore Git for Windows
does not support those commands in the Portable Git.
To help with that, add a simple test helper that exercises the
`run_processes_parallel()` function to allow for running test scripts in
parallel (which is really necessary, especially on Windows, as Git's
test suite takes such a long time to run).
This will also come in handy for the upcoming change to our Azure
Pipeline: we will use this helper in a Portable Git to test the Visual
Studio build of Git.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-10-04 17:09:33 +02:00
|
|
|
struct testsuite {
|
|
|
|
|
struct string_list tests, failed;
|
|
|
|
|
int next;
|
|
|
|
|
int quiet, immediate, verbose, verbose_log, trace, write_junit_xml;
|
|
|
|
|
};
|
|
|
|
|
#define TESTSUITE_INIT \
|
|
|
|
|
{ STRING_LIST_INIT_DUP, STRING_LIST_INIT_DUP, -1, 0, 0, 0, 0, 0, 0 }
|
|
|
|
|
|
|
|
|
|
static int next_test(struct child_process *cp, struct strbuf *err, void *cb,
|
|
|
|
|
void **task_cb)
|
|
|
|
|
{
|
|
|
|
|
struct testsuite *suite = cb;
|
|
|
|
|
const char *test;
|
|
|
|
|
if (suite->next >= suite->tests.nr)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
test = suite->tests.items[suite->next++].string;
|
|
|
|
|
argv_array_pushl(&cp->args, "sh", test, NULL);
|
|
|
|
|
if (suite->quiet)
|
|
|
|
|
argv_array_push(&cp->args, "--quiet");
|
|
|
|
|
if (suite->immediate)
|
|
|
|
|
argv_array_push(&cp->args, "-i");
|
|
|
|
|
if (suite->verbose)
|
|
|
|
|
argv_array_push(&cp->args, "-v");
|
|
|
|
|
if (suite->verbose_log)
|
|
|
|
|
argv_array_push(&cp->args, "-V");
|
|
|
|
|
if (suite->trace)
|
|
|
|
|
argv_array_push(&cp->args, "-x");
|
|
|
|
|
if (suite->write_junit_xml)
|
|
|
|
|
argv_array_push(&cp->args, "--write-junit-xml");
|
|
|
|
|
|
|
|
|
|
strbuf_addf(err, "Output of '%s':\n", test);
|
|
|
|
|
*task_cb = (void *)test;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int test_finished(int result, struct strbuf *err, void *cb,
|
|
|
|
|
void *task_cb)
|
|
|
|
|
{
|
|
|
|
|
struct testsuite *suite = cb;
|
|
|
|
|
const char *name = (const char *)task_cb;
|
|
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
|
string_list_append(&suite->failed, name);
|
|
|
|
|
|
|
|
|
|
strbuf_addf(err, "%s: '%s'\n", result ? "FAIL" : "SUCCESS", name);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int test_failed(struct strbuf *out, void *cb, void *task_cb)
|
|
|
|
|
{
|
|
|
|
|
struct testsuite *suite = cb;
|
|
|
|
|
const char *name = (const char *)task_cb;
|
|
|
|
|
|
|
|
|
|
string_list_append(&suite->failed, name);
|
|
|
|
|
strbuf_addf(out, "FAILED TO START: '%s'\n", name);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char * const testsuite_usage[] = {
|
|
|
|
|
"test-run-command testsuite [<options>] [<pattern>...]",
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int testsuite(int argc, const char **argv)
|
|
|
|
|
{
|
|
|
|
|
struct testsuite suite = TESTSUITE_INIT;
|
|
|
|
|
int max_jobs = 1, i, ret;
|
|
|
|
|
DIR *dir;
|
|
|
|
|
struct dirent *d;
|
|
|
|
|
struct option options[] = {
|
|
|
|
|
OPT_BOOL('i', "immediate", &suite.immediate,
|
|
|
|
|
"stop at first failed test case(s)"),
|
|
|
|
|
OPT_INTEGER('j', "jobs", &max_jobs, "run <N> jobs in parallel"),
|
|
|
|
|
OPT_BOOL('q', "quiet", &suite.quiet, "be terse"),
|
|
|
|
|
OPT_BOOL('v', "verbose", &suite.verbose, "be verbose"),
|
|
|
|
|
OPT_BOOL('V', "verbose-log", &suite.verbose_log,
|
|
|
|
|
"be verbose, redirected to a file"),
|
|
|
|
|
OPT_BOOL('x', "trace", &suite.trace, "trace shell commands"),
|
|
|
|
|
OPT_BOOL(0, "write-junit-xml", &suite.write_junit_xml,
|
|
|
|
|
"write JUnit-style XML files"),
|
|
|
|
|
OPT_END()
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
memset(&suite, 0, sizeof(suite));
|
|
|
|
|
suite.tests.strdup_strings = suite.failed.strdup_strings = 1;
|
|
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, NULL, options,
|
|
|
|
|
testsuite_usage, PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
|
|
|
|
|
|
if (max_jobs <= 0)
|
|
|
|
|
max_jobs = online_cpus();
|
|
|
|
|
|
|
|
|
|
dir = opendir(".");
|
|
|
|
|
if (!dir)
|
|
|
|
|
die("Could not open the current directory");
|
|
|
|
|
while ((d = readdir(dir))) {
|
|
|
|
|
const char *p = d->d_name;
|
|
|
|
|
|
|
|
|
|
if (*p != 't' || !isdigit(p[1]) || !isdigit(p[2]) ||
|
|
|
|
|
!isdigit(p[3]) || !isdigit(p[4]) || p[5] != '-' ||
|
|
|
|
|
!ends_with(p, ".sh"))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* No pattern: match all */
|
|
|
|
|
if (!argc) {
|
|
|
|
|
string_list_append(&suite.tests, p);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
|
if (!wildmatch(argv[i], p, 0)) {
|
|
|
|
|
string_list_append(&suite.tests, p);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
|
|
if (!suite.tests.nr)
|
|
|
|
|
die("No tests match!");
|
|
|
|
|
if (max_jobs > suite.tests.nr)
|
|
|
|
|
max_jobs = suite.tests.nr;
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "Running %d tests (%d at a time)\n",
|
|
|
|
|
suite.tests.nr, max_jobs);
|
|
|
|
|
|
|
|
|
|
ret = run_processes_parallel(max_jobs, next_test, test_failed,
|
|
|
|
|
test_finished, &suite);
|
|
|
|
|
|
|
|
|
|
if (suite.failed.nr > 0) {
|
|
|
|
|
ret = 1;
|
|
|
|
|
fprintf(stderr, "%d tests failed:\n\n", suite.failed.nr);
|
|
|
|
|
for (i = 0; i < suite.failed.nr; i++)
|
|
|
|
|
fprintf(stderr, "\t%s\n", suite.failed.items[i].string);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
string_list_clear(&suite.tests, 0);
|
|
|
|
|
string_list_clear(&suite.failed, 0);
|
|
|
|
|
|
|
|
|
|
return !!ret;
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-18 22:03:59 +02:00
|
|
|
static uint64_t my_random_next = 1234;
|
|
|
|
|
|
|
|
|
|
static uint64_t my_random(void)
|
|
|
|
|
{
|
|
|
|
|
uint64_t res = my_random_next;
|
|
|
|
|
my_random_next = my_random_next * 1103515245 + 12345;
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int quote_stress_test(int argc, const char **argv)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* We are running a quote-stress test.
|
|
|
|
|
* spawn a subprocess that runs quote-stress with a
|
|
|
|
|
* special option that echoes back the arguments that
|
|
|
|
|
* were passed in.
|
|
|
|
|
*/
|
|
|
|
|
char special[] = ".?*\\^_\"'`{}()[]<>@~&+:;$%"; // \t\r\n\a";
|
2019-09-20 00:12:37 +02:00
|
|
|
int i, j, k, trials = 100, skip = 0, msys2 = 0;
|
2019-09-18 22:03:59 +02:00
|
|
|
struct strbuf out = STRBUF_INIT;
|
|
|
|
|
struct argv_array args = ARGV_ARRAY_INIT;
|
|
|
|
|
struct option options[] = {
|
|
|
|
|
OPT_INTEGER('n', "trials", &trials, "Number of trials"),
|
2019-09-19 23:46:31 +02:00
|
|
|
OPT_INTEGER('s', "skip", &skip, "Skip <n> trials"),
|
2019-09-20 00:12:37 +02:00
|
|
|
OPT_BOOL('m', "msys2", &msys2, "Test quoting for MSYS2's sh"),
|
2019-09-18 22:03:59 +02:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
|
|
|
|
const char * const usage[] = {
|
2019-12-04 22:21:20 +01:00
|
|
|
"test-tool run-command quote-stress-test <options>",
|
2019-09-18 22:03:59 +02:00
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, NULL, options, usage, 0);
|
|
|
|
|
|
2019-09-20 00:12:37 +02:00
|
|
|
setenv("MSYS_NO_PATHCONV", "1", 0);
|
|
|
|
|
|
2019-09-18 22:03:59 +02:00
|
|
|
for (i = 0; i < trials; i++) {
|
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2019-09-20 19:09:39 +02:00
|
|
|
size_t arg_count, arg_offset;
|
2019-09-18 22:03:59 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
argv_array_clear(&args);
|
2019-09-20 00:12:37 +02:00
|
|
|
if (msys2)
|
|
|
|
|
argv_array_pushl(&args, "sh", "-c",
|
|
|
|
|
"printf %s\\\\0 \"$@\"", "skip", NULL);
|
|
|
|
|
else
|
2019-12-04 22:21:20 +01:00
|
|
|
argv_array_pushl(&args, "test-tool", "run-command",
|
2019-09-20 00:12:37 +02:00
|
|
|
"quote-echo", NULL);
|
2019-09-18 22:03:59 +02:00
|
|
|
arg_offset = args.argc;
|
2019-09-20 19:09:39 +02:00
|
|
|
|
|
|
|
|
if (argc > 0) {
|
|
|
|
|
trials = 1;
|
|
|
|
|
arg_count = argc;
|
|
|
|
|
for (j = 0; j < arg_count; j++)
|
|
|
|
|
argv_array_push(&args, argv[j]);
|
|
|
|
|
} else {
|
|
|
|
|
arg_count = 1 + (my_random() % 5);
|
|
|
|
|
for (j = 0; j < arg_count; j++) {
|
|
|
|
|
char buf[20];
|
|
|
|
|
size_t min_len = 1;
|
|
|
|
|
size_t arg_len = min_len +
|
|
|
|
|
(my_random() % (ARRAY_SIZE(buf) - min_len));
|
|
|
|
|
|
|
|
|
|
for (k = 0; k < arg_len; k++)
|
|
|
|
|
buf[k] = special[my_random() %
|
|
|
|
|
ARRAY_SIZE(special)];
|
|
|
|
|
buf[arg_len] = '\0';
|
|
|
|
|
|
|
|
|
|
argv_array_push(&args, buf);
|
|
|
|
|
}
|
2019-09-18 22:03:59 +02:00
|
|
|
}
|
|
|
|
|
|
2019-09-19 23:46:31 +02:00
|
|
|
if (i < skip)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-09-18 22:03:59 +02:00
|
|
|
cp.argv = args.argv;
|
|
|
|
|
strbuf_reset(&out);
|
|
|
|
|
if (pipe_command(&cp, NULL, 0, &out, 0, NULL, 0) < 0)
|
|
|
|
|
return error("Failed to spawn child process");
|
|
|
|
|
|
|
|
|
|
for (j = 0, k = 0; j < arg_count; j++) {
|
|
|
|
|
const char *arg = args.argv[j + arg_offset];
|
|
|
|
|
|
|
|
|
|
if (strcmp(arg, out.buf + k))
|
|
|
|
|
ret = error("incorrectly quoted arg: '%s', "
|
|
|
|
|
"echoed back as '%s'",
|
|
|
|
|
arg, out.buf + k);
|
|
|
|
|
k += strlen(out.buf + k) + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (k != out.len)
|
|
|
|
|
ret = error("got %d bytes, but consumed only %d",
|
|
|
|
|
(int)out.len, (int)k);
|
|
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
|
fprintf(stderr, "Trial #%d failed. Arguments:\n", i);
|
|
|
|
|
for (j = 0; j < arg_count; j++)
|
|
|
|
|
fprintf(stderr, "arg #%d: '%s'\n",
|
|
|
|
|
(int)j, args.argv[j + arg_offset]);
|
|
|
|
|
|
|
|
|
|
strbuf_release(&out);
|
|
|
|
|
argv_array_clear(&args);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i && (i % 100) == 0)
|
|
|
|
|
fprintf(stderr, "Trials completed: %d\n", (int)i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
strbuf_release(&out);
|
|
|
|
|
argv_array_clear(&args);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int quote_echo(int argc, const char **argv)
|
|
|
|
|
{
|
|
|
|
|
while (argc > 1) {
|
|
|
|
|
fwrite(argv[1], strlen(argv[1]), 1, stdout);
|
|
|
|
|
fputc('\0', stdout);
|
|
|
|
|
argv++;
|
|
|
|
|
argc--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-22 15:41:02 +01:00
|
|
|
static int inherit_handle(const char *argv0)
|
|
|
|
|
{
|
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
|
char path[PATH_MAX];
|
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
|
|
/* First, open an inheritable handle */
|
|
|
|
|
xsnprintf(path, sizeof(path), "out-XXXXXX");
|
|
|
|
|
tmp = xmkstemp(path);
|
|
|
|
|
|
|
|
|
|
argv_array_pushl(&cp.args,
|
|
|
|
|
"test-tool", argv0, "inherited-handle-child", NULL);
|
|
|
|
|
cp.in = -1;
|
|
|
|
|
cp.no_stdout = cp.no_stderr = 1;
|
|
|
|
|
if (start_command(&cp) < 0)
|
|
|
|
|
die("Could not start child process");
|
|
|
|
|
|
|
|
|
|
/* Then close it, and try to delete it. */
|
|
|
|
|
close(tmp);
|
|
|
|
|
if (unlink(path))
|
|
|
|
|
die("Could not delete '%s'", path);
|
|
|
|
|
|
|
|
|
|
if (close(cp.in) < 0 || finish_command(&cp) < 0)
|
|
|
|
|
die("Child did not finish");
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int inherit_handle_child(void)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
|
|
if (strbuf_read(&buf, 0, 0) < 0)
|
|
|
|
|
die("Could not read stdin");
|
|
|
|
|
printf("Received %s\n", buf.buf);
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-24 08:44:55 +01:00
|
|
|
int cmd__run_command(int argc, const char **argv)
|
2010-01-10 14:11:22 +01:00
|
|
|
{
|
2014-08-19 21:09:35 +02:00
|
|
|
struct child_process proc = CHILD_PROCESS_INIT;
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
int jobs;
|
2010-01-10 14:11:22 +01:00
|
|
|
|
test-tool run-command: learn to run (parts of) the testsuite
Git for Windows jumps through hoops to provide a development environment
that allows to build Git and to run its test suite. To that end, an
entire MSYS2 system, including GNU make and GCC is offered as "the Git
for Windows SDK". It does come at a price: an initial download of said
SDK weighs in with several hundreds of megabytes, and the unpacked SDK
occupies ~2GB of disk space.
A much more native development environment on Windows is Visual Studio.
To help contributors use that environment, we already have a Makefile
target `vcxproj` that generates a commit with project files (and other
generated files), and Git for Windows' `vs/master` branch is
continuously re-generated using that target.
The idea is to allow building Git in Visual Studio, and to run
individual tests using a Portable Git.
The one missing thing is a way to run the entire test suite: neither
`make` nor `prove` are required to run Git, therefore Git for Windows
does not support those commands in the Portable Git.
To help with that, add a simple test helper that exercises the
`run_processes_parallel()` function to allow for running test scripts in
parallel (which is really necessary, especially on Windows, as Git's
test suite takes such a long time to run).
This will also come in handy for the upcoming change to our Azure
Pipeline: we will use this helper in a Portable Git to test the Visual
Studio build of Git.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-10-04 17:09:33 +02:00
|
|
|
if (argc > 1 && !strcmp(argv[1], "testsuite"))
|
|
|
|
|
exit(testsuite(argc - 1, argv + 1));
|
2019-11-22 15:41:02 +01:00
|
|
|
if (!strcmp(argv[1], "inherited-handle"))
|
|
|
|
|
exit(inherit_handle(argv[0]));
|
|
|
|
|
if (!strcmp(argv[1], "inherited-handle-child"))
|
|
|
|
|
exit(inherit_handle_child());
|
test-tool run-command: learn to run (parts of) the testsuite
Git for Windows jumps through hoops to provide a development environment
that allows to build Git and to run its test suite. To that end, an
entire MSYS2 system, including GNU make and GCC is offered as "the Git
for Windows SDK". It does come at a price: an initial download of said
SDK weighs in with several hundreds of megabytes, and the unpacked SDK
occupies ~2GB of disk space.
A much more native development environment on Windows is Visual Studio.
To help contributors use that environment, we already have a Makefile
target `vcxproj` that generates a commit with project files (and other
generated files), and Git for Windows' `vs/master` branch is
continuously re-generated using that target.
The idea is to allow building Git in Visual Studio, and to run
individual tests using a Portable Git.
The one missing thing is a way to run the entire test suite: neither
`make` nor `prove` are required to run Git, therefore Git for Windows
does not support those commands in the Portable Git.
To help with that, add a simple test helper that exercises the
`run_processes_parallel()` function to allow for running test scripts in
parallel (which is really necessary, especially on Windows, as Git's
test suite takes such a long time to run).
This will also come in handy for the upcoming change to our Azure
Pipeline: we will use this helper in a Portable Git to test the Visual
Studio build of Git.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-10-04 17:09:33 +02:00
|
|
|
|
2019-09-18 22:03:59 +02:00
|
|
|
if (argc >= 2 && !strcmp(argv[1], "quote-stress-test"))
|
|
|
|
|
return !!quote_stress_test(argc - 1, argv + 1);
|
|
|
|
|
|
|
|
|
|
if (argc >= 2 && !strcmp(argv[1], "quote-echo"))
|
|
|
|
|
return !!quote_echo(argc - 1, argv + 1);
|
|
|
|
|
|
2018-01-18 10:45:11 +01:00
|
|
|
if (argc < 3)
|
|
|
|
|
return 1;
|
|
|
|
|
while (!strcmp(argv[1], "env")) {
|
|
|
|
|
if (!argv[2])
|
|
|
|
|
die("env specifier without a value");
|
|
|
|
|
argv_array_push(&proc.env_array, argv[2]);
|
|
|
|
|
argv += 2;
|
|
|
|
|
argc -= 2;
|
|
|
|
|
}
|
2010-01-10 14:11:22 +01:00
|
|
|
if (argc < 3)
|
|
|
|
|
return 1;
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
proc.argv = (const char **)argv + 2;
|
2010-01-10 14:11:22 +01:00
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "start-command-ENOENT")) {
|
|
|
|
|
if (start_command(&proc) < 0 && errno == ENOENT)
|
|
|
|
|
return 0;
|
|
|
|
|
fprintf(stderr, "FAIL %s\n", argv[1]);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2011-04-20 12:35:08 +02:00
|
|
|
if (!strcmp(argv[1], "run-command"))
|
|
|
|
|
exit(run_command(&proc));
|
2010-01-10 14:11:22 +01:00
|
|
|
|
run-command: add an asynchronous parallel child processor
This allows to run external commands in parallel with ordered output
on stderr.
If we run external commands in parallel we cannot pipe the output directly
to the our stdout/err as it would mix up. So each process's output will
flow through a pipe, which we buffer. One subprocess can be directly
piped to out stdout/err for a low latency feedback to the user.
Example:
Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a
different amount of time as the different submodules vary in size, then
the output of fetches in sequential order might look like this:
time -->
output: |---A---| |-B-| |-------C-------| |-D-| |-E-|
When we schedule these submodules into maximal two parallel processes,
a schedule and sample output over time may look like this:
process 1: |---A---| |-D-| |-E-|
process 2: |-B-| |-------C-------|
output: |---A---|B|---C-------|DE
So A will be perceived as it would run normally in the single child
version. As B has finished by the time A is done, we can dump its whole
progress buffer on stderr, such that it looks like it finished in no
time. Once that is done, C is determined to be the visible child and
its progress will be reported in real time.
So this way of output is really good for human consumption, as it only
changes the timing, not the actual output.
For machine consumption the output needs to be prepared in the tasks,
by either having a prefix per line or per block to indicate whose tasks
output is displayed, because the output order may not follow the
original sequential ordering:
|----A----| |--B--| |-C-|
will be scheduled to be all parallel:
process 1: |----A----|
process 2: |--B--|
process 3: |-C-|
output: |----A----|CB
This happens because C finished before B did, so it will be queued for
output before B.
To detect when a child has finished executing, we check interleaved
with other actions (such as checking the liveliness of children or
starting new processes) whether the stderr pipe still exists. Once a
child closed its stderr stream, we assume it is terminating very soon,
and use `finish_command()` from the single external process execution
interface to collect the exit status.
By maintaining the strong assumption of stderr being open until the
very end of a child process, we can avoid other hassle such as an
implementation using `waitpid(-1)`, which is not implemented in Windows.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-16 01:04:10 +01:00
|
|
|
jobs = atoi(argv[2]);
|
|
|
|
|
proc.argv = (const char **)argv + 3;
|
|
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "run-command-parallel"))
|
|
|
|
|
exit(run_processes_parallel(jobs, parallel_next,
|
|
|
|
|
NULL, NULL, &proc));
|
|
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "run-command-abort"))
|
|
|
|
|
exit(run_processes_parallel(jobs, parallel_next,
|
|
|
|
|
NULL, task_finished, &proc));
|
|
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "run-command-no-jobs"))
|
|
|
|
|
exit(run_processes_parallel(jobs, no_job,
|
|
|
|
|
NULL, task_finished, &proc));
|
|
|
|
|
|
2010-01-10 14:11:22 +01:00
|
|
|
fprintf(stderr, "check usage\n");
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
