#ifndef ARCH_TESTS_H
 #define ARCH_TESTS_H
 
-extern struct test *arch_tests[];
+extern struct test_suite *arch_tests[];
 
 #endif
 
 #include "tests/tests.h"
 #include "arch-tests.h"
 
-struct test *arch_tests[] = {
+struct test_suite *arch_tests[] = {
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
        &suite__dwarf_unwind,
 #endif
 
 
 #define VECTORS__MAP_NAME "[vectors]"
 
-static int test__vectors_page(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__vectors_page(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        void *start, *end;
 
 
 #ifndef ARCH_TESTS_H
 #define ARCH_TESTS_H
 
-extern struct test *arch_tests[];
+extern struct test_suite *arch_tests[];
 
 #endif
 
 #include "tests/tests.h"
 #include "arch-tests.h"
 
-struct test *arch_tests[] = {
+struct test_suite *arch_tests[] = {
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
        &suite__dwarf_unwind,
 #endif
 
 #ifndef ARCH_TESTS_H
 #define ARCH_TESTS_H
 
-extern struct test *arch_tests[];
+extern struct test_suite *arch_tests[];
 
 #endif
 
 #include "tests/tests.h"
 #include "arch-tests.h"
 
-struct test *arch_tests[] = {
+
+struct test_suite *arch_tests[] = {
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
        &suite__dwarf_unwind,
 #endif
 
 #ifndef ARCH_TESTS_H
 #define ARCH_TESTS_H
 
-struct test;
+struct test_suite;
 
 /* Tests */
-int test__rdpmc(struct test *test, int subtest);
-int test__insn_x86(struct test *test, int subtest);
-int test__intel_pt_pkt_decoder(struct test *test, int subtest);
-int test__bp_modify(struct test *test, int subtest);
-int test__x86_sample_parsing(struct test *test, int subtest);
+int test__rdpmc(struct test_suite *test, int subtest);
+int test__insn_x86(struct test_suite *test, int subtest);
+int test__intel_pt_pkt_decoder(struct test_suite *test, int subtest);
+int test__bp_modify(struct test_suite *test, int subtest);
+int test__x86_sample_parsing(struct test_suite *test, int subtest);
 
-extern struct test *arch_tests[];
+extern struct test_suite *arch_tests[];
 
 #endif
 
 #endif
 DEFINE_SUITE("x86 Sample parsing", x86_sample_parsing);
 
-struct test *arch_tests[] = {
+struct test_suite *arch_tests[] = {
        &suite__rdpmc,
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
        &suite__dwarf_unwind,
 
        return rip == (unsigned long) bp_1 ? TEST_OK : TEST_FAIL;
 }
 
-int test__bp_modify(struct test *test __maybe_unused,
+int test__bp_modify(struct test_suite *test __maybe_unused,
                    int subtest __maybe_unused)
 {
        TEST_ASSERT_VAL("modify test 1 failed\n", !bp_modify1());
 
  * verbose (-v) option to see all the instructions and whether or not they
  * decoded successfully.
  */
-int test__insn_x86(struct test *test __maybe_unused, int subtest __maybe_unused)
+int test__insn_x86(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret = 0;
 
 
  * the last read counter value to avoid triggering a WARN_ON_ONCE() in
  * smp_call_function_many() caused by sending IPIs from NMI context.
  */
-int test__intel_cqm_count_nmi_context(struct test *test __maybe_unused, int subtest __maybe_unused)
+int test__intel_cqm_count_nmi_context(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct evlist *evlist = NULL;
        struct evsel *evsel = NULL;
 
  * This test feeds byte sequences to the Intel PT packet decoder and checks the
  * results. Changes to the packet context are also checked.
  */
-int test__intel_pt_pkt_decoder(struct test *test __maybe_unused, int subtest __maybe_unused)
+int test__intel_pt_pkt_decoder(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct test_data *d = data;
        int ret;
 
        return 0;
 }
 
-int test__rdpmc(struct test *test __maybe_unused, int subtest __maybe_unused)
+int test__rdpmc(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int status = 0;
        int wret = 0;
 
  * For now, the PERF_SAMPLE_WEIGHT_STRUCT is the only X86 specific sample type.
  * The test only checks the PERF_SAMPLE_WEIGHT_STRUCT type.
  */
-int test__x86_sample_parsing(struct test *test __maybe_unused, int subtest __maybe_unused)
+int test__x86_sample_parsing(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        return do_test(PERF_SAMPLE_WEIGHT_STRUCT);
 }
 
        return ret;
 }
 
-static int test__api_io(struct test *test __maybe_unused,
+static int test__api_io(struct test_suite *test __maybe_unused,
                        int subtest __maybe_unused)
 {
        int ret = 0;
 
        return system(cmd) ? TEST_FAIL : TEST_OK;
 }
 
-static int test__attr(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__attr(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct stat st;
        char path_perf[PATH_MAX];
 
 }
 
 
-static int test__backward_ring_buffer(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__backward_ring_buffer(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret = TEST_SKIP, err, sample_count = 0, comm_count = 0;
        char pid[16], sbuf[STRERR_BUFSIZE];
 
        return ret;
 }
 
-static int test__bitmap_print(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__bitmap_print(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1"));
        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1,5"));
 
  *     we create another watchpoint to ensure
  *     the slot accounting is correct
  */
-static int test__bp_accounting(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__bp_accounting(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int has_ioctl = detect_ioctl();
        int wp_cnt = detect_cnt(false);
 #endif
 }
 
-struct test suite__bp_accounting = {
+struct test_suite suite__bp_accounting = {
        .desc = "Breakpoint accounting",
        .func = test__bp_accounting,
        .is_supported = test__bp_account_is_supported,
 
        return count;
 }
 
-static int test__bp_signal(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__bp_signal(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct sigaction sa;
        long long count1, count2, count3;
 #endif
 }
 
-struct test suite__bp_signal = {
+struct test_suite suite__bp_signal = {
        .desc = "Breakpoint overflow signal handler",
        .func = test__bp_signal,
        .is_supported = test__bp_signal_is_supported,
 
 #define EXECUTIONS 10000
 #define THRESHOLD  100
 
-static int test__bp_signal_overflow(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__bp_signal_overflow(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_event_attr pe;
        struct sigaction sa;
        return fails ? TEST_FAIL : TEST_OK;
 }
 
-struct test suite__bp_signal_overflow = {
+struct test_suite suite__bp_signal_overflow = {
        .desc = "Breakpoint overflow sampling",
        .func = test__bp_signal_overflow,
        .is_supported = test__bp_signal_is_supported,
 
        return 0;
 }
 
-static int test__bpf(struct test *test __maybe_unused, int i)
+static int test__bpf(struct test_suite *test __maybe_unused, int i)
 {
        int err;
 
        return NULL;
 }
 
-static int test__bpf(struct test *test __maybe_unused, int i __maybe_unused)
+static int test__bpf(struct test_suite *test __maybe_unused, int i __maybe_unused)
 {
        pr_debug("Skip BPF test because BPF support is not compiled\n");
        return TEST_SKIP;
 }
 #endif
 
-struct test suite__bpf = {
+struct test_suite suite__bpf = {
        .desc = "BPF filter",
        .func = test__bpf,
        .subtest = {
 
 
 static bool dont_fork;
 
-struct test *__weak arch_tests[] = {
+struct test_suite *__weak arch_tests[] = {
        NULL,
 };
 
-static struct test *generic_tests[] = {
+static struct test_suite *generic_tests[] = {
        &suite__vmlinux_matches_kallsyms,
        &suite__openat_syscall_event,
        &suite__openat_syscall_event_on_all_cpus,
        NULL,
 };
 
-static struct test **tests[] = {
+static struct test_suite **tests[] = {
        generic_tests,
        arch_tests,
 };
        return false;
 }
 
-static int run_test(struct test *test, int subtest)
+static int run_test(struct test_suite *test, int subtest)
 {
        int status, err = -1, child = dont_fork ? 0 : fork();
        char sbuf[STRERR_BUFSIZE];
        for (j = 0; j < ARRAY_SIZE(tests); j++) \
                for (k = 0, t = tests[j][k]; tests[j][k]; k++, t = tests[j][k])
 
-static int test_and_print(struct test *t, bool force_skip, int subtest)
+static int test_and_print(struct test_suite *t, bool force_skip, int subtest)
 {
        int err;
 
        const char *file;
 };
 
-static int shell_test__run(struct test *test, int subdir __maybe_unused)
+static int shell_test__run(struct test_suite *test, int subdir __maybe_unused)
 {
        int err;
        char script[PATH_MAX];
        for_each_shell_test(entlist, n_dirs, st.dir, ent) {
                int curr = i++;
                char desc[256];
-               struct test test = {
+               struct test_suite test = {
                        .desc = shell_test__description(desc, sizeof(desc), st.dir, ent->d_name),
                        .func = shell_test__run,
                        .priv = &st,
 
 static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
 {
-       struct test *t;
+       struct test_suite *t;
        unsigned int j, k;
        int i = 0;
        int width = shell_tests__max_desc_width();
        for_each_shell_test(entlist, n_dirs, path, ent) {
                int curr = i++;
                char bf[256];
-               struct test t = {
+               struct test_suite t = {
                        .desc = shell_test__description(bf, sizeof(bf), path, ent->d_name),
                };
 
 static int perf_test__list(int argc, const char **argv)
 {
        unsigned int j, k;
-       struct test *t;
+       struct test_suite *t;
        int i = 0;
 
        for_each_test(j, k, t) {
 
 }
 
 #ifndef HAVE_LIBCLANGLLVM_SUPPORT
-static int test__clang(struct test *test __maybe_unused, int i __maybe_unused)
+static int test__clang(struct test_suite *test __maybe_unused, int i __maybe_unused)
 {
        return TEST_SKIP;
 }
 #else
-static int test__clang(struct test *test __maybe_unused, int i)
+static int test__clang(struct test_suite *test __maybe_unused, int i)
 {
        if (i < 0 || i >= (int)ARRAY_SIZE(clang_testcase_table))
                return TEST_FAIL;
 }
 #endif
 
-struct test suite__clang = {
+struct test_suite suite__clang = {
        .desc = "builtin clang support",
        .func = test__clang,
        .subtest = {
 
        return err;
 }
 
-static int test__code_reading(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__code_reading(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret;
 
 
 }
 
 
-static int test__cpu_map_synthesize(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__cpu_map_synthesize(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_cpu_map *cpus;
 
        return !strcmp(buf, str);
 }
 
-static int test__cpu_map_print(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__cpu_map_print(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1"));
        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1,5"));
        return 0;
 }
 
-static int test__cpu_map_merge(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__cpu_map_merge(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_cpu_map *a = perf_cpu_map__new("4,2,1");
        struct perf_cpu_map *b = perf_cpu_map__new("4,5,7");
 
 #include "debug.h"
 #include "demangle-java.h"
 
-static int test__demangle_java(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__demangle_java(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret = TEST_OK;
        char *buf = NULL;
 
 #include "debug.h"
 #include "demangle-ocaml.h"
 
-static int test__demangle_ocaml(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__demangle_ocaml(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret = TEST_OK;
        char *buf = NULL;
 
        }
 }
 
-static int test__dlfilter(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__dlfilter(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct test_data td = {.fd = -1};
        int pid = getpid();
 
        return fd;
 }
 
-static int test__dso_data(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__dso_data(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct machine machine;
        struct dso *dso;
        return setrlimit(RLIMIT_NOFILE, &rlim);
 }
 
-static int test__dso_data_cache(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__dso_data_cache(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct machine machine;
        long nr_end, nr = open_files_cnt();
        return ret;
 }
 
-static int test__dso_data_reopen(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__dso_data_reopen(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct machine machine;
        long nr_end, nr = open_files_cnt(), lim = new_limit(3);
 
        return ret;
 }
 
-static int test__dwarf_unwind(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__dwarf_unwind(struct test_suite *test __maybe_unused,
+                             int subtest __maybe_unused)
 {
        struct machine *machine;
        struct thread *thread;
 
  * and checks that enabled and running times
  * match.
  */
-static int test__event_times(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__event_times(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err, ret = 0;
 
 
        return 0;
 }
 
-static int test__event_update(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__event_update(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct evsel *evsel;
        struct event_name tmp;
 
 #define perf_evsel__name_array_test(names, distance) \
        __perf_evsel__name_array_test(names, ARRAY_SIZE(names), distance)
 
-static int test__perf_evsel__roundtrip_name_test(struct test *test __maybe_unused,
+static int test__perf_evsel__roundtrip_name_test(struct test_suite *test __maybe_unused,
                                                 int subtest __maybe_unused)
 {
        int err = 0, ret = 0;
 
        return ret;
 }
 
-static int test__perf_evsel__tp_sched_test(struct test *test __maybe_unused,
+static int test__perf_evsel__tp_sched_test(struct test_suite *test __maybe_unused,
                                           int subtest __maybe_unused)
 {
        struct evsel *evsel = evsel__newtp("sched", "sched_switch");
 
        return ret;
 }
 
-static int test__expand_cgroup_events(struct test *test __maybe_unused,
+static int test__expand_cgroup_events(struct test_suite *test __maybe_unused,
                                      int subtest __maybe_unused)
 {
        int ret;
 
        return 0;
 }
 
-static int test__expr(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        struct expr_id_data *val_ptr;
        const char *p;
 
        return printed + fdarray__fprintf(fda, fp);
 }
 
-static int test__fdarray__filter(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__fdarray__filter(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int nr_fds, err = TEST_FAIL;
        struct fdarray *fda = fdarray__new(5, 5);
        return err;
 }
 
-static int test__fdarray__add(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__fdarray__add(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = TEST_FAIL;
        struct fdarray *fda = fdarray__new(2, 2);
 
 
 #define TEMPL "/tmp/perf-test-XXXXXX"
 
-static int test__jit_write_elf(struct test *test __maybe_unused,
+static int test__jit_write_elf(struct test_suite *test __maybe_unused,
                               int subtest __maybe_unused)
 {
 #ifdef HAVE_JITDUMP
 
        return err;
 }
 
-static int test__hists_cumulate(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__hists_cumulate(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = TEST_FAIL;
        struct machines machines;
 
        return TEST_FAIL;
 }
 
-static int test__hists_filter(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__hists_filter(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = TEST_FAIL;
        struct machines machines;
 
        return __validate_link(leader, 0) || __validate_link(other, 1);
 }
 
-static int test__hists_link(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__hists_link(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = -1;
        struct hists *hists, *first_hists;
 
        return err;
 }
 
-static int test__hists_output(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__hists_output(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = TEST_FAIL;
        struct machines machines;
 
 #include "debug.h"
 #include "print_binary.h"
 
-static int test__is_printable_array(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__is_printable_array(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        char buf1[] = { 'k', 'r', 4, 'v', 'a', 0 };
        char buf2[] = { 'k', 'r', 'a', 'v', 4, 0 };
 
  * when an event is disabled but a dummy software event is not disabled.  If the
  * test passes %0 is returned, otherwise %-1 is returned.
  */
-static int test__keep_tracking(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__keep_tracking(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct record_opts opts = {
                .mmap_pages          = UINT_MAX,
 
 #define M(path, c, e) \
        TEST_ASSERT_VAL("failed", !test_is_kernel_module(path, c, e))
 
-static int test__kmod_path__parse(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__kmod_path__parse(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        /* path                alloc_name  kmod  comp   name   */
        T("/xxxx/xxxx/x-x.ko", true      , true, 0    , "[x_x]");
 
        return ret;
 }
 
-static int test__llvm(struct test *test __maybe_unused, int subtest)
+static int test__llvm(struct test_suite *test __maybe_unused, int subtest)
 {
        int ret;
        void *obj_buf = NULL;
        return bpf_source_table[subtest].desc;
 }
 #else //HAVE_LIBBPF_SUPPORT
-static int test__llvm(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__llvm(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        return TEST_SKIP;
 }
 }
 #endif // HAVE_LIBBPF_SUPPORT
 
-struct test suite__llvm = {
+struct test_suite suite__llvm = {
        .desc = "LLVM search and compile",
        .func = test__llvm,
        .subtest = {
 
        return TEST_OK;
 }
 
-static int test__maps__merge_in(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__maps__merge_in(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        struct maps maps;
        unsigned int i;
 
        return 0;
 }
 
-static int test__mem(struct test *text __maybe_unused, int subtest __maybe_unused)
+static int test__mem(struct test_suite *text __maybe_unused, int subtest __maybe_unused)
 {
        int ret = 0;
        union perf_mem_data_src src;
 
        return bm && map ? bm : NULL;
 }
 
-static int test__mem2node(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__mem2node(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        struct mem2node map;
        struct memory_node nodes[3];
 
  * Then it checks if the number of syscalls reported as perf events by
  * the kernel corresponds to the number of syscalls made.
  */
-static int test__basic_mmap(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__basic_mmap(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = -1;
        union perf_event *event;
 
  *
  * by using all thread objects.
  */
-static int test__mmap_thread_lookup(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__mmap_thread_lookup(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        /* perf_event__synthesize_threads synthesize */
        TEST_ASSERT_VAL("failed with sythesizing all",
 
 #include "stat.h"
 #include "util/counts.h"
 
-static int test__openat_syscall_event_on_all_cpus(struct test *test __maybe_unused,
+static int test__openat_syscall_event_on_all_cpus(struct test_suite *test __maybe_unused,
                                                  int subtest __maybe_unused)
 {
        int err = -1, fd, cpu;
 
 #define AT_FDCWD       -100
 #endif
 
-static int test__syscall_openat_tp_fields(struct test *test __maybe_unused,
+static int test__syscall_openat_tp_fields(struct test_suite *test __maybe_unused,
                                          int subtest __maybe_unused)
 {
        struct record_opts opts = {
 
 #include "tests.h"
 #include "util/counts.h"
 
-static int test__openat_syscall_event(struct test *test __maybe_unused,
+static int test__openat_syscall_event(struct test_suite *test __maybe_unused,
                                      int subtest __maybe_unused)
 {
        int err = -1, fd;
 
        return test_event(&e);
 }
 
-static int test__parse_events(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__parse_events(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret1, ret2 = 0;
        char *event, *alias;
 
        return 0;
 }
 
-static int test__parse_metric(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__parse_metric(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        TEST_ASSERT_VAL("IPC failed", test_ipc() == 0);
        TEST_ASSERT_VAL("frontend failed", test_frontend() == 0);
 
  *
  * Return: %0 on success, %-1 if the test fails.
  */
-static int test__parse_no_sample_id_all(struct test *test __maybe_unused,
+static int test__parse_no_sample_id_all(struct test_suite *test __maybe_unused,
                                        int subtest __maybe_unused)
 {
        int err;
 
        return TEST_OK;
 }
 
-static int test__pe_file_parsing(struct test *test __maybe_unused,
+static int test__pe_file_parsing(struct test_suite *test __maybe_unused,
                          int subtest __maybe_unused)
 {
        struct stat st;
 
 #else
 
-static int test__pe_file_parsing(struct test *test __maybe_unused,
+static int test__pe_file_parsing(struct test_suite *test __maybe_unused,
                          int subtest __maybe_unused)
 {
        return TEST_SKIP;
 
        raise(SIGSEGV);
 }
 
-static int test__perf_hooks(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__perf_hooks(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int hook_flags = 0;
 
 
        return cpu;
 }
 
-static int test__PERF_RECORD(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__PERF_RECORD(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct record_opts opts = {
                .target = {
 
  * %0 is returned, otherwise %-1 is returned.  If TSC conversion is not
  * supported then then the test passes but " (not supported)" is printed.
  */
-static int test__perf_time_to_tsc(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__perf_time_to_tsc(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct record_opts opts = {
                .mmap_pages          = UINT_MAX,
 #endif
 }
 
-struct test suite__perf_time_to_tsc = {
+struct test_suite suite__perf_time_to_tsc = {
        .desc = "Convert perf time to TSC",
        .func = test__perf_time_to_tsc,
        .is_supported = test__tsc_is_supported,
 
        return (int)ARRAY_SIZE(pfm_testcase_table);
 }
 
-static int test__pfm(struct test *test __maybe_unused, int i __maybe_unused)
+static int test__pfm(struct test_suite *test __maybe_unused, int i __maybe_unused)
 {
 #ifdef HAVE_LIBPFM
        if (i < 0 || i >= (int)ARRAY_SIZE(pfm_testcase_table))
 #endif
 }
 
-struct test suite__pfm = {
+struct test_suite suite__pfm = {
        .desc = "Test libpfm4 support",
        .func = test__pfm,
        .subtest = {
 
        return (int)ARRAY_SIZE(pmu_events_testcase_table);
 }
 
-static int test__pmu_events(struct test *test __maybe_unused, int subtest)
+static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest)
 {
        if (subtest < 0 ||
            subtest >= (int)ARRAY_SIZE(pmu_events_testcase_table))
        return pmu_events_testcase_table[subtest].func();
 }
 
-struct test suite__pmu_events = {
+struct test_suite suite__pmu_events = {
        .desc = "PMU events",
        .func = test__pmu_events,
        .subtest = {
 
        return &terms;
 }
 
-static int test__pmu(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__pmu(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        char *format = test_format_dir_get();
        LIST_HEAD(formats);
 
 #include "tests.h"
 #include "util/debug.h"
 
-static int test__python_use(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__python_use(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        char *cmd;
        int ret;
 
  * checks sample format bits separately and together.  If the test passes %0 is
  * returned, otherwise %-1 is returned.
  */
-static int test__sample_parsing(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__sample_parsing(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        const u64 rf[] = {4, 5, 6, 7, 12, 13, 14, 15};
        u64 sample_type;
 
        return ret;
 }
 
-static int test__sdt_event(struct test *test __maybe_unused, int subtests __maybe_unused)
+static int test__sdt_event(struct test_suite *test __maybe_unused, int subtests __maybe_unused)
 {
        int ret = TEST_FAIL;
        char __tempdir[] = "./test-buildid-XXXXXX";
        return ret;
 }
 #else
-static int test__sdt_event(struct test *test __maybe_unused, int subtests __maybe_unused)
+static int test__sdt_event(struct test_suite *test __maybe_unused, int subtests __maybe_unused)
 {
        pr_debug("Skip SDT event test because SDT support is not compiled\n");
        return TEST_SKIP;
 
        return 0;
 }
 
-static int test__synthesize_stat_config(struct test *test __maybe_unused,
+static int test__synthesize_stat_config(struct test_suite *test __maybe_unused,
                                        int subtest __maybe_unused)
 {
        struct perf_stat_config stat_config = {
        return 0;
 }
 
-static int test__synthesize_stat(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__synthesize_stat(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_counts_values count;
 
        return 0;
 }
 
-static int test__synthesize_stat_round(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__synthesize_stat_round(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        TEST_ASSERT_VAL("failed to synthesize stat_config",
                !perf_event__synthesize_stat_round(NULL, 0xdeadbeef, PERF_STAT_ROUND_TYPE__INTERVAL,
 
        return err;
 }
 
-static int test__sw_clock_freq(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__sw_clock_freq(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int ret;
 
 
  * evsel->core.system_wide and evsel->tracking flags (respectively) with other events
  * sometimes enabled or disabled.
  */
-static int test__switch_tracking(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__switch_tracking(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        const char *sched_switch = "sched:sched_switch";
        struct switch_tracking switch_tracking = { .tids = NULL, };
 
  * if the number of exit event reported by the kernel is 1 or not
  * in order to check the kernel returns correct number of event.
  */
-static int test__task_exit(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__task_exit(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        int err = -1;
        union perf_event *event;
 
        TEST_SKIP = -2,
 };
 
-struct test {
+struct test_suite {
        const char *desc;
-       int (*func)(struct test *test, int subtest);
+       int (*func)(struct test_suite *test, int subtest);
        struct {
                bool skip_if_fail;
                int (*get_nr)(void);
 };
 
 #define DECLARE_SUITE(name) \
-       extern struct test suite__##name;
+       extern struct test_suite suite__##name;
 
 #define DEFINE_SUITE(description, name)                \
-       struct test suite__##name = {           \
+       struct test_suite suite__##name = {             \
                .desc = description,            \
                .func = test__##name,           \
        }
 
 #define NAME   (const char *) "perf"
 #define NAMEUL (unsigned long) NAME
 
-static int test__thread_map(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__thread_map(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_thread_map *map;
 
        return 0;
 }
 
-static int test__thread_map_synthesize(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__thread_map_synthesize(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_thread_map *threads;
 
        return 0;
 }
 
-static int test__thread_map_remove(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__thread_map_remove(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct perf_thread_map *threads;
        char *str;
 
 #include "thread.h"
 #include "debug.h"
 
-static int test__thread_maps_share(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__thread_maps_share(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        struct machines machines;
        struct machine *machine;
 
        return pass;
 }
 
-static int test__time_utils(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__time_utils(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        bool pass = true;
 
 
        return 0;
 }
 
-static int test__session_topology(struct test *test __maybe_unused, int subtest __maybe_unused)
+static int test__session_topology(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
 {
        char path[PATH_MAX];
        struct perf_cpu_map *map;
 
 #include "units.h"
 #include "debug.h"
 
-static int test__unit_number__scnprint(struct test *t __maybe_unused, int subtest __maybe_unused)
+static int test__unit_number__scnprint(struct test_suite *t __maybe_unused, int subtest __maybe_unused)
 {
        struct {
                u64              n;
 
        return false;
 }
 
-static int test__vmlinux_matches_kallsyms(struct test *test __maybe_unused,
+static int test__vmlinux_matches_kallsyms(struct test_suite *test __maybe_unused,
                                        int subtest __maybe_unused)
 {
        int err = -1;
 
        return wp_testcase_table[i].skip_msg();
 }
 
-static int test__wp(struct test *test __maybe_unused, int i)
+static int test__wp(struct test_suite *test __maybe_unused, int i)
 {
        if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
                return TEST_FAIL;
 #endif
 }
 
-struct test suite__wp = {
+struct test_suite suite__wp = {
        .desc = "Watchpoint",
        .func = test__wp,
        .is_supported = test__wp_is_supported,