mirror of
https://github.com/git/git
synced 2024-08-28 12:09:19 +00:00
![Junio C Hamano](/assets/img/avatar_default.png)
More header clean-up. * en/header-split-cache-h-part-2: (22 commits) reftable: ensure git-compat-util.h is the first (indirect) include diff.h: reduce unnecessary includes object-store.h: reduce unnecessary includes commit.h: reduce unnecessary includes fsmonitor: reduce includes of cache.h cache.h: remove unnecessary headers treewide: remove cache.h inclusion due to previous changes cache,tree: move basic name compare functions from read-cache to tree cache,tree: move cmp_cache_name_compare from tree.[ch] to read-cache.c hash-ll.h: split out of hash.h to remove dependency on repository.h tree-diff.c: move S_DIFFTREE_IFXMIN_NEQ define from cache.h dir.h: move DTYPE defines from cache.h versioncmp.h: move declarations for versioncmp.c functions from cache.h ws.h: move declarations for ws.c functions from cache.h match-trees.h: move declarations for match-trees.c functions from cache.h pkt-line.h: move declarations for pkt-line.c functions from cache.h base85.h: move declarations for base85.c functions from cache.h copy.h: move declarations for copy.c functions from cache.h server-info.h: move declarations for server-info.c functions from cache.h packfile.h: move pack_window and pack_entry from cache.h ...
499 lines
13 KiB
C
499 lines
13 KiB
C
#include "test-tool.h"
|
|
#include "strvec.h"
|
|
#include "run-command.h"
|
|
#include "exec-cmd.h"
|
|
#include "config.h"
|
|
#include "repository.h"
|
|
#include "trace2.h"
|
|
|
|
typedef int(fn_unit_test)(int argc, const char **argv);
|
|
|
|
struct unit_test {
|
|
fn_unit_test *ut_fn;
|
|
const char *ut_name;
|
|
const char *ut_usage;
|
|
};
|
|
|
|
#define MyOk 0
|
|
#define MyError 1
|
|
|
|
static int get_i(int *p_value, const char *data)
|
|
{
|
|
char *endptr;
|
|
|
|
if (!data || !*data)
|
|
return MyError;
|
|
|
|
*p_value = strtol(data, &endptr, 10);
|
|
if (*endptr || errno == ERANGE)
|
|
return MyError;
|
|
|
|
return MyOk;
|
|
}
|
|
|
|
/*
|
|
* Cause process to exit with the requested value via "return".
|
|
*
|
|
* Rely on test-tool.c:cmd_main() to call trace2_cmd_exit()
|
|
* with our result.
|
|
*
|
|
* Test harness can confirm:
|
|
* [] the process-exit value.
|
|
* [] the "code" field in the "exit" trace2 event.
|
|
* [] the "code" field in the "atexit" trace2 event.
|
|
* [] the "name" field in the "cmd_name" trace2 event.
|
|
* [] "def_param" events for all of the "interesting" pre-defined
|
|
* config settings.
|
|
*/
|
|
static int ut_001return(int argc, const char **argv)
|
|
{
|
|
int rc;
|
|
|
|
if (get_i(&rc, argv[0]))
|
|
die("expect <exit_code>");
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Cause the process to exit with the requested value via "exit()".
|
|
*
|
|
* Test harness can confirm:
|
|
* [] the "code" field in the "exit" trace2 event.
|
|
* [] the "code" field in the "atexit" trace2 event.
|
|
* [] the "name" field in the "cmd_name" trace2 event.
|
|
* [] "def_param" events for all of the "interesting" pre-defined
|
|
* config settings.
|
|
*/
|
|
static int ut_002exit(int argc, const char **argv)
|
|
{
|
|
int rc;
|
|
|
|
if (get_i(&rc, argv[0]))
|
|
die("expect <exit_code>");
|
|
|
|
exit(rc);
|
|
}
|
|
|
|
/*
|
|
* Send an "error" event with each value in argv. Normally, git only issues
|
|
* a single "error" event immediately before issuing an "exit" event (such
|
|
* as in die() or BUG()), but multiple "error" events are allowed.
|
|
*
|
|
* Test harness can confirm:
|
|
* [] a trace2 "error" event for each value in argv.
|
|
* [] the "name" field in the "cmd_name" trace2 event.
|
|
* [] (optional) the file:line in the "exit" event refers to this function.
|
|
*/
|
|
static int ut_003error(int argc, const char **argv)
|
|
{
|
|
int k;
|
|
|
|
if (!argv[0] || !*argv[0])
|
|
die("expect <error_message>");
|
|
|
|
for (k = 0; k < argc; k++)
|
|
error("%s", argv[k]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Run a child process and wait for it to finish and exit with its return code.
|
|
* test-tool trace2 004child [<child-command-line>]
|
|
*
|
|
* For example:
|
|
* test-tool trace2 004child git version
|
|
* test-tool trace2 004child test-tool trace2 001return 0
|
|
* test-tool trace2 004child test-tool trace2 004child test-tool trace2 004child
|
|
* test-tool trace2 004child git -c alias.xyz=version xyz
|
|
*
|
|
* Test harness can confirm:
|
|
* [] the "name" field in the "cmd_name" trace2 event.
|
|
* [] that the outer process has a single component SID (or depth "d0" in
|
|
* the PERF stream).
|
|
* [] that "child_start" and "child_exit" events are generated for the child.
|
|
* [] if the child process is an instrumented executable:
|
|
* [] that "version", "start", ..., "exit", and "atexit" events are
|
|
* generated by the child process.
|
|
* [] that the child process events have a multiple component SID (or
|
|
* depth "dN+1" in the PERF stream).
|
|
* [] that the child exit code is propagated to the parent process "exit"
|
|
* and "atexit" events..
|
|
* [] (optional) that the "t_abs" field in the child process "atexit" event
|
|
* is less than the "t_rel" field in the "child_exit" event of the parent
|
|
* process.
|
|
* [] if the child process is like the alias example above,
|
|
* [] (optional) the child process attempts to run "git-xyx" as a dashed
|
|
* command.
|
|
* [] the child process emits an "alias" event with "xyz" => "version"
|
|
* [] the child process runs "git version" as a child process.
|
|
* [] the child process has a 3 component SID (or depth "d2" in the PERF
|
|
* stream).
|
|
*/
|
|
static int ut_004child(int argc, const char **argv)
|
|
{
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
|
int result;
|
|
|
|
/*
|
|
* Allow empty <child_command_line> so we can do arbitrarily deep
|
|
* command nesting and let the last one be null.
|
|
*/
|
|
if (!argc)
|
|
return 0;
|
|
|
|
strvec_pushv(&cmd.args, argv);
|
|
result = run_command(&cmd);
|
|
exit(result);
|
|
}
|
|
|
|
/*
|
|
* Exec a git command. This may either create a child process (Windows)
|
|
* or replace the existing process.
|
|
* test-tool trace2 005exec <git_command_args>
|
|
*
|
|
* For example:
|
|
* test-tool trace2 005exec version
|
|
*
|
|
* Test harness can confirm (on Windows):
|
|
* [] the "name" field in the "cmd_name" trace2 event.
|
|
* [] that the outer process has a single component SID (or depth "d0" in
|
|
* the PERF stream).
|
|
* [] that "exec" and "exec_result" events are generated for the child
|
|
* process (since the Windows compatibility layer fakes an exec() with
|
|
* a CreateProcess(), WaitForSingleObject(), and exit()).
|
|
* [] that the child process has multiple component SID (or depth "dN+1"
|
|
* in the PERF stream).
|
|
*
|
|
* Test harness can confirm (on platforms with a real exec() function):
|
|
* [] TODO talk about process replacement and how it affects SID.
|
|
*/
|
|
static int ut_005exec(int argc, const char **argv)
|
|
{
|
|
int result;
|
|
|
|
if (!argc)
|
|
return 0;
|
|
|
|
result = execv_git_cmd(argv);
|
|
return result;
|
|
}
|
|
|
|
static int ut_006data(int argc, const char **argv)
|
|
{
|
|
const char *usage_error =
|
|
"expect <cat0> <k0> <v0> [<cat1> <k1> <v1> [...]]";
|
|
|
|
if (argc % 3 != 0)
|
|
die("%s", usage_error);
|
|
|
|
while (argc) {
|
|
if (!argv[0] || !*argv[0] || !argv[1] || !*argv[1] ||
|
|
!argv[2] || !*argv[2])
|
|
die("%s", usage_error);
|
|
|
|
trace2_data_string(argv[0], the_repository, argv[1], argv[2]);
|
|
argv += 3;
|
|
argc -= 3;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ut_007BUG(int argc, const char **argv)
|
|
{
|
|
/*
|
|
* Exercise BUG() to ensure that the message is printed to trace2.
|
|
*/
|
|
BUG("the bug message");
|
|
}
|
|
|
|
static int ut_008bug(int argc UNUSED, const char **argv UNUSED)
|
|
{
|
|
bug("a bug message");
|
|
bug("another bug message");
|
|
BUG_if_bug("an explicit BUG_if_bug() following bug() call(s) is nice, but not required");
|
|
return 0;
|
|
}
|
|
|
|
static int ut_009bug_BUG(int argc UNUSED, const char **argv UNUSED)
|
|
{
|
|
bug("a bug message");
|
|
bug("another bug message");
|
|
/* The BUG_if_bug(...) isn't here, but we'll spot bug() calls on exit()! */
|
|
return 0;
|
|
}
|
|
|
|
static int ut_010bug_BUG(int argc UNUSED, const char **argv UNUSED)
|
|
{
|
|
bug("a %s message", "bug");
|
|
BUG("a %s message", "BUG");
|
|
}
|
|
|
|
/*
|
|
* Single-threaded timer test. Create several intervals using the
|
|
* TEST1 timer. The test script can verify that an aggregate Trace2
|
|
* "timer" event is emitted indicating that we started+stopped the
|
|
* timer the requested number of times.
|
|
*/
|
|
static int ut_100timer(int argc, const char **argv)
|
|
{
|
|
const char *usage_error =
|
|
"expect <count> <ms_delay>";
|
|
|
|
int count = 0;
|
|
int delay = 0;
|
|
int k;
|
|
|
|
if (argc != 2)
|
|
die("%s", usage_error);
|
|
if (get_i(&count, argv[0]))
|
|
die("%s", usage_error);
|
|
if (get_i(&delay, argv[1]))
|
|
die("%s", usage_error);
|
|
|
|
for (k = 0; k < count; k++) {
|
|
trace2_timer_start(TRACE2_TIMER_ID_TEST1);
|
|
sleep_millisec(delay);
|
|
trace2_timer_stop(TRACE2_TIMER_ID_TEST1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct ut_101_data {
|
|
int count;
|
|
int delay;
|
|
};
|
|
|
|
static void *ut_101timer_thread_proc(void *_ut_101_data)
|
|
{
|
|
struct ut_101_data *data = _ut_101_data;
|
|
int k;
|
|
|
|
trace2_thread_start("ut_101");
|
|
|
|
for (k = 0; k < data->count; k++) {
|
|
trace2_timer_start(TRACE2_TIMER_ID_TEST2);
|
|
sleep_millisec(data->delay);
|
|
trace2_timer_stop(TRACE2_TIMER_ID_TEST2);
|
|
}
|
|
|
|
trace2_thread_exit();
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Multi-threaded timer test. Create several threads that each create
|
|
* several intervals using the TEST2 timer. The test script can verify
|
|
* that an individual Trace2 "th_timer" events for each thread and an
|
|
* aggregate "timer" event are generated.
|
|
*/
|
|
static int ut_101timer(int argc, const char **argv)
|
|
{
|
|
const char *usage_error =
|
|
"expect <count> <ms_delay> <threads>";
|
|
|
|
struct ut_101_data data = { 0, 0 };
|
|
int nr_threads = 0;
|
|
int k;
|
|
pthread_t *pids = NULL;
|
|
|
|
if (argc != 3)
|
|
die("%s", usage_error);
|
|
if (get_i(&data.count, argv[0]))
|
|
die("%s", usage_error);
|
|
if (get_i(&data.delay, argv[1]))
|
|
die("%s", usage_error);
|
|
if (get_i(&nr_threads, argv[2]))
|
|
die("%s", usage_error);
|
|
|
|
CALLOC_ARRAY(pids, nr_threads);
|
|
|
|
for (k = 0; k < nr_threads; k++) {
|
|
if (pthread_create(&pids[k], NULL, ut_101timer_thread_proc, &data))
|
|
die("failed to create thread[%d]", k);
|
|
}
|
|
|
|
for (k = 0; k < nr_threads; k++) {
|
|
if (pthread_join(pids[k], NULL))
|
|
die("failed to join thread[%d]", k);
|
|
}
|
|
|
|
free(pids);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Single-threaded counter test. Add several values to the TEST1 counter.
|
|
* The test script can verify that the final sum is reported in the "counter"
|
|
* event.
|
|
*/
|
|
static int ut_200counter(int argc, const char **argv)
|
|
{
|
|
const char *usage_error =
|
|
"expect <v1> [<v2> [...]]";
|
|
int value;
|
|
int k;
|
|
|
|
if (argc < 1)
|
|
die("%s", usage_error);
|
|
|
|
for (k = 0; k < argc; k++) {
|
|
if (get_i(&value, argv[k]))
|
|
die("invalid value[%s] -- %s",
|
|
argv[k], usage_error);
|
|
trace2_counter_add(TRACE2_COUNTER_ID_TEST1, value);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Multi-threaded counter test. Create seveal threads that each increment
|
|
* the TEST2 global counter. The test script can verify that an individual
|
|
* "th_counter" event is generated with a partial sum for each thread and
|
|
* that a final aggregate "counter" event is generated.
|
|
*/
|
|
|
|
struct ut_201_data {
|
|
int v1;
|
|
int v2;
|
|
};
|
|
|
|
static void *ut_201counter_thread_proc(void *_ut_201_data)
|
|
{
|
|
struct ut_201_data *data = _ut_201_data;
|
|
|
|
trace2_thread_start("ut_201");
|
|
|
|
trace2_counter_add(TRACE2_COUNTER_ID_TEST2, data->v1);
|
|
trace2_counter_add(TRACE2_COUNTER_ID_TEST2, data->v2);
|
|
|
|
trace2_thread_exit();
|
|
return NULL;
|
|
}
|
|
|
|
static int ut_201counter(int argc, const char **argv)
|
|
{
|
|
const char *usage_error =
|
|
"expect <v1> <v2> <threads>";
|
|
|
|
struct ut_201_data data = { 0, 0 };
|
|
int nr_threads = 0;
|
|
int k;
|
|
pthread_t *pids = NULL;
|
|
|
|
if (argc != 3)
|
|
die("%s", usage_error);
|
|
if (get_i(&data.v1, argv[0]))
|
|
die("%s", usage_error);
|
|
if (get_i(&data.v2, argv[1]))
|
|
die("%s", usage_error);
|
|
if (get_i(&nr_threads, argv[2]))
|
|
die("%s", usage_error);
|
|
|
|
CALLOC_ARRAY(pids, nr_threads);
|
|
|
|
for (k = 0; k < nr_threads; k++) {
|
|
if (pthread_create(&pids[k], NULL, ut_201counter_thread_proc, &data))
|
|
die("failed to create thread[%d]", k);
|
|
}
|
|
|
|
for (k = 0; k < nr_threads; k++) {
|
|
if (pthread_join(pids[k], NULL))
|
|
die("failed to join thread[%d]", k);
|
|
}
|
|
|
|
free(pids);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Usage:
|
|
* test-tool trace2 <ut_name_1> <ut_usage_1>
|
|
* test-tool trace2 <ut_name_2> <ut_usage_2>
|
|
* ...
|
|
*/
|
|
#define USAGE_PREFIX "test-tool trace2"
|
|
|
|
/* clang-format off */
|
|
static struct unit_test ut_table[] = {
|
|
{ ut_001return, "001return", "<exit_code>" },
|
|
{ ut_002exit, "002exit", "<exit_code>" },
|
|
{ ut_003error, "003error", "<error_message>+" },
|
|
{ ut_004child, "004child", "[<child_command_line>]" },
|
|
{ ut_005exec, "005exec", "<git_command_args>" },
|
|
{ ut_006data, "006data", "[<category> <key> <value>]+" },
|
|
{ ut_007BUG, "007bug", "" },
|
|
{ ut_008bug, "008bug", "" },
|
|
{ ut_009bug_BUG, "009bug_BUG","" },
|
|
{ ut_010bug_BUG, "010bug_BUG","" },
|
|
|
|
{ ut_100timer, "100timer", "<count> <ms_delay>" },
|
|
{ ut_101timer, "101timer", "<count> <ms_delay> <threads>" },
|
|
|
|
{ ut_200counter, "200counter", "<v1> [<v2> [<v3> [...]]]" },
|
|
{ ut_201counter, "201counter", "<v1> <v2> <threads>" },
|
|
};
|
|
/* clang-format on */
|
|
|
|
/* clang-format off */
|
|
#define for_each_ut(k, ut_k) \
|
|
for (k = 0, ut_k = &ut_table[k]; \
|
|
k < ARRAY_SIZE(ut_table); \
|
|
k++, ut_k = &ut_table[k])
|
|
/* clang-format on */
|
|
|
|
static int print_usage(void)
|
|
{
|
|
int k;
|
|
struct unit_test *ut_k;
|
|
|
|
fprintf(stderr, "usage:\n");
|
|
for_each_ut (k, ut_k)
|
|
fprintf(stderr, "\t%s %s %s\n", USAGE_PREFIX, ut_k->ut_name,
|
|
ut_k->ut_usage);
|
|
|
|
return 129;
|
|
}
|
|
|
|
/*
|
|
* Issue various trace2 events for testing.
|
|
*
|
|
* We assume that these trace2 routines has already been called:
|
|
* [] trace2_initialize() [common-main.c:main()]
|
|
* [] trace2_cmd_start() [common-main.c:main()]
|
|
* [] trace2_cmd_name() [test-tool.c:cmd_main()]
|
|
* [] tracd2_cmd_list_config() [test-tool.c:cmd_main()]
|
|
* So that:
|
|
* [] the various trace2 streams are open.
|
|
* [] the process SID has been created.
|
|
* [] the "version" event has been generated.
|
|
* [] the "start" event has been generated.
|
|
* [] the "cmd_name" event has been generated.
|
|
* [] this writes various "def_param" events for interesting config values.
|
|
*
|
|
* We return from here and let test-tool.c::cmd_main() pass the exit
|
|
* code to common-main.c::main(), which will use it to call
|
|
* trace2_cmd_exit().
|
|
*/
|
|
int cmd__trace2(int argc, const char **argv)
|
|
{
|
|
int k;
|
|
struct unit_test *ut_k;
|
|
|
|
argc--; /* skip over "trace2" arg */
|
|
argv++;
|
|
|
|
if (argc)
|
|
for_each_ut (k, ut_k)
|
|
if (!strcmp(argv[0], ut_k->ut_name))
|
|
return ut_k->ut_fn(argc - 1, argv + 1);
|
|
|
|
return print_usage();
|
|
}
|