parse-events.c

   1// SPDX-License-Identifier: GPL-2.0
   2#include "parse-events.h"
   3#include "evsel.h"
   4#include "evsel_fprintf.h"
   5#include "evlist.h"
   6#include <api/fs/fs.h>
   7#include "tests.h"
   8#include "debug.h"
   9#include "pmu.h"
  10#include "pmus.h"
  11#include "strbuf.h"
  12#include <dirent.h>
  13#include <errno.h>
  14#include "fncache.h"
  15#include <sys/types.h>
  16#include <sys/stat.h>
  17#include <unistd.h>
  18#include <linux/kernel.h>
  19#include <linux/hw_breakpoint.h>
  20#include <api/fs/tracing_path.h>
  21
  22#define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
  23			     PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
  24
  25static bool check_evlist(const char *test, int line, bool cond, struct evlist *evlist)
  26{
  27	struct strbuf sb = STRBUF_INIT;
  28
  29	if (cond)
  30		return true;
  31
  32	evlist__format_evsels(evlist, &sb, 2048);
  33	pr_debug("FAILED %s:%d: %s\nFor evlist: %s\n", __FILE__, line, test, sb.buf);
  34	strbuf_release(&sb);
  35	return false;
  36}
  37#define TEST_ASSERT_EVLIST(test, cond, evlist) \
  38	if (!check_evlist(test, __LINE__, cond, evlist)) \
  39		return TEST_FAIL
  40
  41static bool check_evsel(const char *test, int line, bool cond, struct evsel *evsel)
  42{
  43	struct perf_attr_details details = { .verbose = true, };
  44
  45	if (cond)
  46		return true;
  47
  48	pr_debug("FAILED %s:%d: %s\nFor evsel: ", __FILE__, line, test);
  49	evsel__fprintf(evsel, &details, debug_file());
  50	return false;
  51}
  52#define TEST_ASSERT_EVSEL(test, cond, evsel) \
  53	if (!check_evsel(test, __LINE__, cond, evsel)) \
  54		return TEST_FAIL
  55
  56static int num_core_entries(struct evlist *evlist)
  57{
  58	/*
  59	 * Returns number of core PMUs if the evlist has >1 core PMU, otherwise
  60	 * returns 1.  The number of core PMUs is needed as wild carding can
  61	 * open an event for each core PMU. If the events were opened with a
  62	 * specified PMU then wild carding won't happen.
  63	 */
  64	struct perf_pmu *core_pmu = NULL;
  65	struct evsel *evsel;
  66
  67	evlist__for_each_entry(evlist, evsel) {
  68		if (!evsel->pmu->is_core)
  69			continue;
  70		if (core_pmu != evsel->pmu && core_pmu != NULL)
  71			return perf_pmus__num_core_pmus();
  72		core_pmu = evsel->pmu;
  73	}
  74	return 1;
  75}
  76
  77static bool test_hw_config(const struct evsel *evsel, __u64 expected_config)
  78{
  79	return (evsel->core.attr.config & PERF_HW_EVENT_MASK) == expected_config;
  80}
  81
  82#if defined(__s390x__)
  83/* Return true if kvm module is available and loaded. Test this
  84 * and return success when trace point kvm_s390_create_vm
  85 * exists. Otherwise this test always fails.
  86 */
  87static bool kvm_s390_create_vm_valid(void)
  88{
  89	char *eventfile;
  90	bool rc = false;
  91
  92	eventfile = get_events_file("kvm-s390");
  93
  94	if (eventfile) {
  95		DIR *mydir = opendir(eventfile);
  96
  97		if (mydir) {
  98			rc = true;
  99			closedir(mydir);
 100		}
 101		put_events_file(eventfile);
 102	}
 103
 104	return rc;
 105}
 106#endif
 107
 108static int test__checkevent_tracepoint(struct evlist *evlist)
 109{
 110	struct evsel *evsel = evlist__first(evlist);
 111
 112	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 113	TEST_ASSERT_EVLIST("wrong number of groups", 0 == evlist__nr_groups(evlist), evlist);
 114	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type, evsel);
 115	TEST_ASSERT_EVSEL("wrong sample_type",
 116			  PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type, evsel);
 117	TEST_ASSERT_EVSEL("wrong sample_period", 1 == evsel->core.attr.sample_period, evsel);
 118	return TEST_OK;
 119}
 120
 121static int test__checkevent_tracepoint_multi(struct evlist *evlist)
 122{
 123	struct evsel *evsel;
 124
 125	TEST_ASSERT_EVLIST("wrong number of entries", evlist->core.nr_entries > 1, evlist);
 126	TEST_ASSERT_EVLIST("wrong number of groups", 0 == evlist__nr_groups(evlist), evlist);
 127
 128	evlist__for_each_entry(evlist, evsel) {
 129		TEST_ASSERT_EVSEL("wrong type",
 130				  PERF_TYPE_TRACEPOINT == evsel->core.attr.type,
 131				  evsel);
 132		TEST_ASSERT_EVSEL("wrong sample_type",
 133				  PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type,
 134				  evsel);
 135		TEST_ASSERT_EVSEL("wrong sample_period",
 136				  1 == evsel->core.attr.sample_period,
 137				  evsel);
 138	}
 139	return TEST_OK;
 140}
 141
 142static int test__checkevent_raw(struct evlist *evlist)
 143{
 144	struct evsel *evsel;
 145	bool raw_type_match = false;
 146
 147	TEST_ASSERT_EVLIST("wrong number of entries", 0 != evlist->core.nr_entries, evlist);
 148
 149	evlist__for_each_entry(evlist, evsel) {
 150		struct perf_pmu *pmu __maybe_unused = NULL;
 151		bool type_matched = false;
 152
 153		TEST_ASSERT_EVSEL("wrong config", test_hw_config(evsel, 0x1a), evsel);
 154		TEST_ASSERT_EVSEL("event not parsed as raw type",
 155				  evsel->core.attr.type == PERF_TYPE_RAW,
 156				  evsel);
 157#if defined(__aarch64__)
 158		/*
 159		 * Arm doesn't have a real raw type PMU in sysfs, so raw events
 160		 * would never match any PMU. However, RAW events on Arm will
 161		 * always successfully open on the first available core PMU
 162		 * so no need to test for a matching type here.
 163		 */
 164		type_matched = raw_type_match = true;
 165#else
 166		while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 167			if (pmu->type == evsel->core.attr.type) {
 168				TEST_ASSERT_EVSEL("PMU type expected once", !type_matched, evsel);
 169				type_matched = true;
 170				if (pmu->type == PERF_TYPE_RAW)
 171					raw_type_match = true;
 172			}
 173		}
 174#endif
 175		TEST_ASSERT_EVSEL("No PMU found for type", type_matched, evsel);
 176	}
 177	TEST_ASSERT_VAL("Raw PMU not matched", raw_type_match);
 178	return TEST_OK;
 179}
 180
 181static int test__checkevent_numeric(struct evlist *evlist)
 182{
 183	struct evsel *evsel = evlist__first(evlist);
 184
 185	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 186	TEST_ASSERT_EVSEL("wrong type", 1 == evsel->core.attr.type, evsel);
 187	TEST_ASSERT_EVSEL("wrong config", 1 == evsel->core.attr.config, evsel);
 188	return TEST_OK;
 189}
 190
 191
 192static int test__checkevent_symbolic_name(struct evlist *evlist)
 193{
 194	struct evsel *evsel;
 195
 196	TEST_ASSERT_EVLIST("wrong number of entries", 0 != evlist->core.nr_entries, evlist);
 197
 198	evlist__for_each_entry(evlist, evsel) {
 199		TEST_ASSERT_EVSEL("unexpected event",
 200				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
 201				  evsel);
 202	}
 203	return TEST_OK;
 204}
 205
 206static int test__checkevent_symbolic_name_config(struct evlist *evlist)
 207{
 208	struct evsel *evsel;
 209
 210	TEST_ASSERT_EVLIST("wrong number of entries", 0 != evlist->core.nr_entries, evlist);
 211
 212	evlist__for_each_entry(evlist, evsel) {
 213		TEST_ASSERT_EVSEL("unexpected event",
 214				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
 215				  evsel);
 216		/*
 217		 * The period value gets configured within evlist__config,
 218		 * while this test executes only parse events method.
 219		 */
 220		TEST_ASSERT_EVSEL("wrong period", 0 == evsel->core.attr.sample_period, evsel);
 221		TEST_ASSERT_EVSEL("wrong config1", 0 == evsel->core.attr.config1, evsel);
 222		TEST_ASSERT_EVSEL("wrong config2", 1 == evsel->core.attr.config2, evsel);
 223	}
 224	return TEST_OK;
 225}
 226
 227static int test__checkevent_symbolic_alias(struct evlist *evlist)
 228{
 229	struct evsel *evsel = evlist__first(evlist);
 230
 231	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 232	TEST_ASSERT_EVSEL("wrong type/config", evsel__match(evsel, SOFTWARE, SW_PAGE_FAULTS),
 233			  evsel);
 234	return TEST_OK;
 235}
 236
 237static int test__checkevent_genhw(struct evlist *evlist)
 238{
 239	struct evsel *evsel;
 240
 241	TEST_ASSERT_EVLIST("wrong number of entries", 0 != evlist->core.nr_entries, evlist);
 242
 243	evlist__for_each_entry(evlist, evsel) {
 244		TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type, evsel);
 245		TEST_ASSERT_EVSEL("wrong config", test_hw_config(evsel, 1 << 16), evsel);
 246	}
 247	return TEST_OK;
 248}
 249
 250static int test__checkevent_breakpoint(struct evlist *evlist)
 251{
 252	struct evsel *evsel = evlist__first(evlist);
 253
 254	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 255	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 256	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
 257	TEST_ASSERT_EVSEL("wrong bp_type",
 258			  (HW_BREAKPOINT_R | HW_BREAKPOINT_W) == evsel->core.attr.bp_type,
 259			  evsel);
 260	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len, evsel);
 261	return TEST_OK;
 262}
 263
 264static int test__checkevent_breakpoint_x(struct evlist *evlist)
 265{
 266	struct evsel *evsel = evlist__first(evlist);
 267
 268	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 269	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 270	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
 271	TEST_ASSERT_EVSEL("wrong bp_type", HW_BREAKPOINT_X == evsel->core.attr.bp_type, evsel);
 272	TEST_ASSERT_EVSEL("wrong bp_len", default_breakpoint_len() == evsel->core.attr.bp_len,
 273			  evsel);
 274	return TEST_OK;
 275}
 276
 277static int test__checkevent_breakpoint_r(struct evlist *evlist)
 278{
 279	struct evsel *evsel = evlist__first(evlist);
 280
 281	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 282	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 283	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
 284	TEST_ASSERT_EVSEL("wrong bp_type", HW_BREAKPOINT_R == evsel->core.attr.bp_type, evsel);
 285	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len, evsel);
 286	return TEST_OK;
 287}
 288
 289static int test__checkevent_breakpoint_w(struct evlist *evlist)
 290{
 291	struct evsel *evsel = evlist__first(evlist);
 292
 293	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 294	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 295	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
 296	TEST_ASSERT_EVSEL("wrong bp_type", HW_BREAKPOINT_W == evsel->core.attr.bp_type, evsel);
 297	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len, evsel);
 298	return TEST_OK;
 299}
 300
 301static int test__checkevent_breakpoint_rw(struct evlist *evlist)
 302{
 303	struct evsel *evsel = evlist__first(evlist);
 304
 305	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 306	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 307	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
 308	TEST_ASSERT_EVSEL("wrong bp_type",
 309			  (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->core.attr.bp_type,
 310			  evsel);
 311	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len, evsel);
 312	return TEST_OK;
 313}
 314
 315static int test__checkevent_tracepoint_modifier(struct evlist *evlist)
 316{
 317	struct evsel *evsel = evlist__first(evlist);
 318
 319	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 320	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 321	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 322	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 323	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 324
 325	return test__checkevent_tracepoint(evlist);
 326}
 327
 328static int
 329test__checkevent_tracepoint_multi_modifier(struct evlist *evlist)
 330{
 331	struct evsel *evsel;
 332
 333	TEST_ASSERT_EVLIST("wrong number of entries", evlist->core.nr_entries > 1, evlist);
 334
 335	evlist__for_each_entry(evlist, evsel) {
 336		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 337		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 338		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 339		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 340	}
 341
 342	return test__checkevent_tracepoint_multi(evlist);
 343}
 344
 345static int test__checkevent_raw_modifier(struct evlist *evlist)
 346{
 347	struct evsel *evsel;
 348
 349	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 350
 351	evlist__for_each_entry(evlist, evsel) {
 352		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 353		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 354		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 355		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 356	}
 357	return test__checkevent_raw(evlist);
 358}
 359
 360static int test__checkevent_numeric_modifier(struct evlist *evlist)
 361{
 362	struct evsel *evsel;
 363
 364	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 365
 366	evlist__for_each_entry(evlist, evsel) {
 367		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 368		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 369		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 370		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 371	}
 372	return test__checkevent_numeric(evlist);
 373}
 374
 375static int test__checkevent_symbolic_name_modifier(struct evlist *evlist)
 376{
 377	struct evsel *evsel;
 378
 379	TEST_ASSERT_EVLIST("wrong number of entries",
 380			   evlist->core.nr_entries == num_core_entries(evlist),
 381			   evlist);
 382
 383	evlist__for_each_entry(evlist, evsel) {
 384		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 385		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 386		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 387		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 388	}
 389	return test__checkevent_symbolic_name(evlist);
 390}
 391
 392static int test__checkevent_exclude_host_modifier(struct evlist *evlist)
 393{
 394	struct evsel *evsel;
 395
 396	TEST_ASSERT_EVLIST("wrong number of entries",
 397			   evlist->core.nr_entries == num_core_entries(evlist),
 398			   evlist);
 399
 400	evlist__for_each_entry(evlist, evsel) {
 401		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
 402		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
 403	}
 404	return test__checkevent_symbolic_name(evlist);
 405}
 406
 407static int test__checkevent_exclude_guest_modifier(struct evlist *evlist)
 408{
 409	struct evsel *evsel;
 410
 411	TEST_ASSERT_EVLIST("wrong number of entries",
 412			   evlist->core.nr_entries == num_core_entries(evlist),
 413			   evlist);
 414
 415	evlist__for_each_entry(evlist, evsel) {
 416		TEST_ASSERT_EVSEL("wrong exclude guest", evsel->core.attr.exclude_guest, evsel);
 417		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
 418	}
 419	return test__checkevent_symbolic_name(evlist);
 420}
 421
 422static int test__checkevent_symbolic_alias_modifier(struct evlist *evlist)
 423{
 424	struct evsel *evsel = evlist__first(evlist);
 425
 426	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
 427	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 428	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 429	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 430	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 431
 432	return test__checkevent_symbolic_alias(evlist);
 433}
 434
 435static int test__checkevent_genhw_modifier(struct evlist *evlist)
 436{
 437	struct evsel *evsel;
 438
 439	TEST_ASSERT_EVLIST("wrong number of entries",
 440			   evlist->core.nr_entries == num_core_entries(evlist),
 441			   evlist);
 442
 443	evlist__for_each_entry(evlist, evsel) {
 444		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 445		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 446		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 447		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 448	}
 449	return test__checkevent_genhw(evlist);
 450}
 451
 452static int test__checkevent_exclude_idle_modifier(struct evlist *evlist)
 453{
 454	struct evsel *evsel = evlist__first(evlist);
 455
 456	TEST_ASSERT_EVLIST("wrong number of entries",
 457			   evlist->core.nr_entries == num_core_entries(evlist),
 458			   evlist);
 459
 460	TEST_ASSERT_EVSEL("wrong exclude idle", evsel->core.attr.exclude_idle, evsel);
 461	TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
 462	TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
 463	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 464	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 465	TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 466	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 467
 468	return test__checkevent_symbolic_name(evlist);
 469}
 470
 471static int test__checkevent_exclude_idle_modifier_1(struct evlist *evlist)
 472{
 473	struct evsel *evsel = evlist__first(evlist);
 474
 475	TEST_ASSERT_EVLIST("wrong number of entries",
 476			   evlist->core.nr_entries == num_core_entries(evlist),
 477			   evlist);
 478
 479	TEST_ASSERT_EVSEL("wrong exclude idle", evsel->core.attr.exclude_idle, evsel);
 480	TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
 481	TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
 482	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 483	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 484	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 485	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 486
 487	return test__checkevent_symbolic_name(evlist);
 488}
 489
 490static int test__checkevent_breakpoint_modifier(struct evlist *evlist)
 491{
 492	struct evsel *evsel = evlist__first(evlist);
 493
 494
 495	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 496	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 497	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 498	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 499	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "mem:0:u"), evsel);
 500
 501	return test__checkevent_breakpoint(evlist);
 502}
 503
 504static int test__checkevent_breakpoint_x_modifier(struct evlist *evlist)
 505{
 506	struct evsel *evsel = evlist__first(evlist);
 507
 508	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 509	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 510	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 511	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 512	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "mem:0:x:k"), evsel);
 513
 514	return test__checkevent_breakpoint_x(evlist);
 515}
 516
 517static int test__checkevent_breakpoint_r_modifier(struct evlist *evlist)
 518{
 519	struct evsel *evsel = evlist__first(evlist);
 520
 521	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 522	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 523	TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 524	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 525	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "mem:0:r:hp"), evsel);
 526
 527	return test__checkevent_breakpoint_r(evlist);
 528}
 529
 530static int test__checkevent_breakpoint_w_modifier(struct evlist *evlist)
 531{
 532	struct evsel *evsel = evlist__first(evlist);
 533
 534	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 535	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 536	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 537	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 538	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "mem:0:w:up"), evsel);
 539
 540	return test__checkevent_breakpoint_w(evlist);
 541}
 542
 543static int test__checkevent_breakpoint_rw_modifier(struct evlist *evlist)
 544{
 545	struct evsel *evsel = evlist__first(evlist);
 546
 547	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 548	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 549	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 550	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 551	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "mem:0:rw:kp"), evsel);
 552
 553	return test__checkevent_breakpoint_rw(evlist);
 554}
 555
 556static int test__checkevent_breakpoint_modifier_name(struct evlist *evlist)
 557{
 558	struct evsel *evsel = evlist__first(evlist);
 559
 560	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 561	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 562	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 563	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 564	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint"), evsel);
 565
 566	return test__checkevent_breakpoint(evlist);
 567}
 568
 569static int test__checkevent_breakpoint_x_modifier_name(struct evlist *evlist)
 570{
 571	struct evsel *evsel = evlist__first(evlist);
 572
 573	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 574	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 575	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 576	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 577	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint"), evsel);
 578
 579	return test__checkevent_breakpoint_x(evlist);
 580}
 581
 582static int test__checkevent_breakpoint_r_modifier_name(struct evlist *evlist)
 583{
 584	struct evsel *evsel = evlist__first(evlist);
 585
 586	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 587	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 588	TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 589	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 590	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint"), evsel);
 591
 592	return test__checkevent_breakpoint_r(evlist);
 593}
 594
 595static int test__checkevent_breakpoint_w_modifier_name(struct evlist *evlist)
 596{
 597	struct evsel *evsel = evlist__first(evlist);
 598
 599	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 600	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 601	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 602	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 603	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint"), evsel);
 604
 605	return test__checkevent_breakpoint_w(evlist);
 606}
 607
 608static int test__checkevent_breakpoint_rw_modifier_name(struct evlist *evlist)
 609{
 610	struct evsel *evsel = evlist__first(evlist);
 611
 612	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 613	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 614	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 615	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 616	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint"), evsel);
 617
 618	return test__checkevent_breakpoint_rw(evlist);
 619}
 620
 621static int test__checkevent_breakpoint_2_events(struct evlist *evlist)
 622{
 623	struct evsel *evsel = evlist__first(evlist);
 624
 625	TEST_ASSERT_EVSEL("wrong number of entries", 2 == evlist->core.nr_entries, evsel);
 626
 627	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 628	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint1"), evsel);
 629
 630	evsel = evsel__next(evsel);
 631
 632	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
 633	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "breakpoint2"), evsel);
 634
 635	return TEST_OK;
 636}
 637
 638static int test__checkevent_pmu(struct evlist *evlist)
 639{
 640
 641	struct evsel *evsel = evlist__first(evlist);
 642	struct perf_pmu *core_pmu = perf_pmus__find_core_pmu();
 643
 644	TEST_ASSERT_EVSEL("wrong number of entries", 1 == evlist->core.nr_entries, evsel);
 645	TEST_ASSERT_EVSEL("wrong type", core_pmu->type == evsel->core.attr.type, evsel);
 646	TEST_ASSERT_EVSEL("wrong config",    test_hw_config(evsel, 10), evsel);
 647	TEST_ASSERT_EVSEL("wrong config1",    1 == evsel->core.attr.config1, evsel);
 648	TEST_ASSERT_EVSEL("wrong config2",    3 == evsel->core.attr.config2, evsel);
 649	TEST_ASSERT_EVSEL("wrong config3",    0 == evsel->core.attr.config3, evsel);
 650	TEST_ASSERT_EVSEL("wrong config4",    0 == evsel->core.attr.config4, evsel);
 651	/*
 652	 * The period value gets configured within evlist__config,
 653	 * while this test executes only parse events method.
 654	 */
 655	TEST_ASSERT_EVSEL("wrong period",     0 == evsel->core.attr.sample_period, evsel);
 656
 657	return TEST_OK;
 658}
 659
 660static int test__checkevent_list(struct evlist *evlist)
 661{
 662	struct evsel *evsel = evlist__first(evlist);
 663
 664	TEST_ASSERT_EVSEL("wrong number of entries", 3 <= evlist->core.nr_entries, evsel);
 665
 666	/* r1 */
 667	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_TRACEPOINT != evsel->core.attr.type, evsel);
 668	while (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
 669		TEST_ASSERT_EVSEL("wrong config", 1 == evsel->core.attr.config, evsel);
 670		TEST_ASSERT_EVSEL("wrong config1", 0 == evsel->core.attr.config1, evsel);
 671		TEST_ASSERT_EVSEL("wrong config2", 0 == evsel->core.attr.config2, evsel);
 672		TEST_ASSERT_EVSEL("wrong config3", 0 == evsel->core.attr.config3, evsel);
 673		TEST_ASSERT_EVSEL("wrong config4", 0 == evsel->core.attr.config4, evsel);
 674		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 675		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 676		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 677		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 678		evsel = evsel__next(evsel);
 679	}
 680
 681	/* syscalls:sys_enter_openat:k */
 682	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type, evsel);
 683	TEST_ASSERT_EVSEL("wrong sample_type", PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type,
 684			  evsel);
 685	TEST_ASSERT_EVSEL("wrong sample_period", 1 == evsel->core.attr.sample_period, evsel);
 686	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 687	TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 688	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 689	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 690
 691	/* 1:1:hp */
 692	evsel = evsel__next(evsel);
 693	TEST_ASSERT_EVSEL("wrong type", 1 == evsel->core.attr.type, evsel);
 694	TEST_ASSERT_EVSEL("wrong config", 1 == evsel->core.attr.config, evsel);
 695	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 696	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 697	TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
 698	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
 699
 700	return TEST_OK;
 701}
 702
 703static int test__checkevent_pmu_name(struct evlist *evlist)
 704{
 705	struct evsel *evsel = evlist__first(evlist);
 706	struct perf_pmu *core_pmu = perf_pmus__find_core_pmu();
 707	char buf[256];
 708
 709	/* default_core/config=1,name=krava/u */
 710	TEST_ASSERT_EVLIST("wrong number of entries", 2 == evlist->core.nr_entries, evlist);
 711	TEST_ASSERT_EVSEL("wrong type", core_pmu->type == evsel->core.attr.type, evsel);
 712	TEST_ASSERT_EVSEL("wrong config", 1 == evsel->core.attr.config, evsel);
 713	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, "krava"), evsel);
 714
 715	/* default_core/config=2/u" */
 716	evsel = evsel__next(evsel);
 717	TEST_ASSERT_EVSEL("wrong number of entries", 2 == evlist->core.nr_entries, evsel);
 718	TEST_ASSERT_EVSEL("wrong type", core_pmu->type == evsel->core.attr.type, evsel);
 719	TEST_ASSERT_EVSEL("wrong config", 2 == evsel->core.attr.config, evsel);
 720	snprintf(buf, sizeof(buf), "%s/config=2/u", core_pmu->name);
 721	TEST_ASSERT_EVSEL("wrong name", evsel__name_is(evsel, buf), evsel);
 722
 723	return TEST_OK;
 724}
 725
 726static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist)
 727{
 728	struct evsel *evsel = evlist__first(evlist);
 729	struct perf_pmu *core_pmu = perf_pmus__find_core_pmu();
 730
 731	/* default_core/config=1,call-graph=fp,time,period=100000/ */
 732	TEST_ASSERT_EVLIST("wrong number of entries", 2 == evlist->core.nr_entries, evlist);
 733	TEST_ASSERT_EVSEL("wrong type", core_pmu->type == evsel->core.attr.type, evsel);
 734	TEST_ASSERT_EVSEL("wrong config", 1 == evsel->core.attr.config, evsel);
 735	/*
 736	 * The period, time and callgraph value gets configured within evlist__config,
 737	 * while this test executes only parse events method.
 738	 */
 739	TEST_ASSERT_EVSEL("wrong period",     0 == evsel->core.attr.sample_period, evsel);
 740	TEST_ASSERT_EVSEL("wrong callgraph",  !evsel__has_callchain(evsel), evsel);
 741	TEST_ASSERT_EVSEL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type), evsel);
 742
 743	/* default_core/config=2,call-graph=no,time=0,period=2000/ */
 744	evsel = evsel__next(evsel);
 745	TEST_ASSERT_EVSEL("wrong type", core_pmu->type == evsel->core.attr.type, evsel);
 746	TEST_ASSERT_EVSEL("wrong config", 2 == evsel->core.attr.config, evsel);
 747	/*
 748	 * The period, time and callgraph value gets configured within evlist__config,
 749	 * while this test executes only parse events method.
 750	 */
 751	TEST_ASSERT_EVSEL("wrong period",     0 == evsel->core.attr.sample_period, evsel);
 752	TEST_ASSERT_EVSEL("wrong callgraph",  !evsel__has_callchain(evsel), evsel);
 753	TEST_ASSERT_EVSEL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type), evsel);
 754
 755	return TEST_OK;
 756}
 757
 758static int test__checkevent_pmu_events(struct evlist *evlist)
 759{
 760	struct evsel *evsel;
 761	struct perf_pmu *core_pmu = perf_pmus__find_core_pmu();
 762
 763	TEST_ASSERT_EVLIST("wrong number of entries", 1 <= evlist->core.nr_entries, evlist);
 764
 765	evlist__for_each_entry(evlist, evsel) {
 766		TEST_ASSERT_EVSEL("wrong type",
 767				  core_pmu->type == evsel->core.attr.type ||
 768				  !strncmp(evsel__name(evsel), evsel->pmu->name,
 769					  strlen(evsel->pmu->name)),
 770				  evsel);
 771		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 772		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 773		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 774		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 775		TEST_ASSERT_EVSEL("wrong pinned", !evsel->core.attr.pinned, evsel);
 776		TEST_ASSERT_EVSEL("wrong exclusive", !evsel->core.attr.exclusive, evsel);
 777	}
 778	return TEST_OK;
 779}
 780
 781
 782static int test__checkevent_pmu_events_mix(struct evlist *evlist)
 783{
 784	struct evsel *evsel = NULL;
 785
 786	/*
 787	 * The wild card event will be opened at least once, but it may be
 788	 * opened on each core PMU.
 789	 */
 790	TEST_ASSERT_EVLIST("wrong number of entries", evlist->core.nr_entries >= 2, evlist);
 791	for (int i = 0; i < evlist->core.nr_entries - 1; i++) {
 792		evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
 793		/* pmu-event:u */
 794		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 795		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 796		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 797		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 798		TEST_ASSERT_EVSEL("wrong pinned", !evsel->core.attr.pinned, evsel);
 799		TEST_ASSERT_EVSEL("wrong exclusive", !evsel->core.attr.exclusive, evsel);
 800	}
 801	/* default_core/pmu-event/u*/
 802	evsel = evsel__next(evsel);
 803	TEST_ASSERT_EVSEL("wrong type", evsel__find_pmu(evsel)->is_core, evsel);
 804	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 805	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 806	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 807	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 808	TEST_ASSERT_EVSEL("wrong pinned", !evsel->core.attr.pinned, evsel);
 809	TEST_ASSERT_EVSEL("wrong exclusive", !evsel->core.attr.pinned, evsel);
 810
 811	return TEST_OK;
 812}
 813
 814static int test__checkterms_simple(struct parse_events_terms *terms)
 815{
 816	struct parse_events_term *term;
 817
 818	/* config=10 */
 819	term = list_entry(terms->terms.next, struct parse_events_term, list);
 820	TEST_ASSERT_VAL("wrong type term",
 821			term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
 822	TEST_ASSERT_VAL("wrong type val",
 823			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 824	TEST_ASSERT_VAL("wrong val", term->val.num == 10);
 825	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config"));
 826
 827	/* config1 */
 828	term = list_entry(term->list.next, struct parse_events_term, list);
 829	TEST_ASSERT_VAL("wrong type term",
 830			term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
 831	TEST_ASSERT_VAL("wrong type val",
 832			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 833	TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 834	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config1"));
 835
 836	/* config2=3 */
 837	term = list_entry(term->list.next, struct parse_events_term, list);
 838	TEST_ASSERT_VAL("wrong type term",
 839			term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
 840	TEST_ASSERT_VAL("wrong type val",
 841			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 842	TEST_ASSERT_VAL("wrong val", term->val.num == 3);
 843	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config2"));
 844
 845	/* config3=4 */
 846	term = list_entry(term->list.next, struct parse_events_term, list);
 847	TEST_ASSERT_VAL("wrong type term",
 848			term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG3);
 849	TEST_ASSERT_VAL("wrong type val",
 850			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 851	TEST_ASSERT_VAL("wrong val", term->val.num == 4);
 852	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config3"));
 853
 854	/* config4=5 */
 855	term = list_entry(term->list.next, struct parse_events_term, list);
 856	TEST_ASSERT_VAL("wrong type term",
 857			term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG4);
 858	TEST_ASSERT_VAL("wrong type val",
 859			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 860	TEST_ASSERT_VAL("wrong val", term->val.num == 5);
 861	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config4"));
 862
 863	/* umask=1*/
 864	term = list_entry(term->list.next, struct parse_events_term, list);
 865	TEST_ASSERT_VAL("wrong type term",
 866			term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
 867	TEST_ASSERT_VAL("wrong type val",
 868			term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 869	TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 870	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask"));
 871
 872	/*
 873	 * read
 874	 *
 875	 * The perf_pmu__test_parse_init injects 'read' term into
 876	 * perf_pmu_events_list, so 'read' is evaluated as read term
 877	 * and not as raw event with 'ead' hex value.
 878	 */
 879	term = list_entry(term->list.next, struct parse_events_term, list);
 880	TEST_ASSERT_VAL("wrong type term",
 881			term->type_term == PARSE_EVENTS__TERM_TYPE_RAW);
 882	TEST_ASSERT_VAL("wrong type val",
 883			term->type_val == PARSE_EVENTS__TERM_TYPE_STR);
 884	TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "read"));
 885	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw"));
 886
 887	/*
 888	 * r0xead
 889	 *
 890	 * To be still able to pass 'ead' value with 'r' syntax,
 891	 * we added support to parse 'r0xHEX' event.
 892	 */
 893	term = list_entry(term->list.next, struct parse_events_term, list);
 894	TEST_ASSERT_VAL("wrong type term",
 895			term->type_term == PARSE_EVENTS__TERM_TYPE_RAW);
 896	TEST_ASSERT_VAL("wrong type val",
 897			term->type_val == PARSE_EVENTS__TERM_TYPE_STR);
 898	TEST_ASSERT_VAL("wrong val", !strcmp(term->val.str, "r0xead"));
 899	TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "raw"));
 900	return TEST_OK;
 901}
 902
 903static int test__group1(struct evlist *evlist)
 904{
 905	struct evsel *evsel = NULL, *leader;
 906
 907	TEST_ASSERT_EVLIST("wrong number of entries",
 908			   evlist->core.nr_entries == (num_core_entries(evlist) * 2),
 909			   evlist);
 910	TEST_ASSERT_EVLIST("wrong number of groups",
 911			   evlist__nr_groups(evlist) == num_core_entries(evlist),
 912			   evlist);
 913
 914	for (int i = 0; i < num_core_entries(evlist); i++) {
 915		/* instructions:k */
 916		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
 917		TEST_ASSERT_EVSEL("unexpected event",
 918				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
 919				  evsel);
 920		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
 921		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
 922		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 923		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
 924		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
 925		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 926		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
 927		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
 928		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
 929		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
 930
 931		/* cycles:upp */
 932		evsel = evsel__next(evsel);
 933		TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
 934				  evsel);
 935		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
 936		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
 937		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 938		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
 939		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
 940		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip == 2, evsel);
 941		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
 942		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
 943		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
 944	}
 945	return TEST_OK;
 946}
 947
 948static int test__group2(struct evlist *evlist)
 949{
 950	struct evsel *evsel, *leader = NULL;
 951
 952	TEST_ASSERT_EVLIST("wrong number of entries",
 953			   evlist->core.nr_entries == (2 * num_core_entries(evlist) + 1),
 954			   evlist);
 955	/*
 956	 * TODO: Currently the software event won't be grouped with the hardware
 957	 * event except for 1 PMU.
 958	 */
 959	TEST_ASSERT_EVLIST("wrong number of groups", 1 == evlist__nr_groups(evlist), evlist);
 960
 961	evlist__for_each_entry(evlist, evsel) {
 962		if (evsel__match(evsel, SOFTWARE, SW_PAGE_FAULTS)) {
 963			/* faults + :ku modifier */
 964			leader = evsel;
 965			TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user,
 966					  evsel);
 967			TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel,
 968					  evsel);
 969			TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 970			TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest,
 971					  evsel);
 972			TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host,
 973					  evsel);
 974			TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 975			TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
 976			TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2,
 977					  evsel);
 978			TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
 979			TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
 980			continue;
 981		}
 982		if (evsel__match(evsel, HARDWARE, HW_BRANCH_INSTRUCTIONS)) {
 983			/* branches + :u modifier */
 984			TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user,
 985					  evsel);
 986			TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel,
 987					  evsel);
 988			TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
 989			TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest,
 990					  evsel);
 991			TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host,
 992					  evsel);
 993			TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
 994			if (evsel__has_leader(evsel, leader)) {
 995				TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1,
 996						  evsel);
 997			}
 998			TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
 999			continue;
1000		}
1001		/* cycles:k */
1002		TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1003				  evsel);
1004		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
1005		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1006		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1007		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1008		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1009		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1010		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1011		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1012	}
1013	return TEST_OK;
1014}
1015
1016static int test__group3(struct evlist *evlist __maybe_unused)
1017{
1018	struct evsel *evsel, *group1_leader = NULL, *group2_leader = NULL;
1019
1020	TEST_ASSERT_EVLIST("wrong number of entries",
1021			   evlist->core.nr_entries == (3 * perf_pmus__num_core_pmus() + 2),
1022			   evlist);
1023	/*
1024	 * Currently the software event won't be grouped with the hardware event
1025	 * except for 1 PMU. This means there are always just 2 groups
1026	 * regardless of the number of core PMUs.
1027	 */
1028	TEST_ASSERT_EVLIST("wrong number of groups", 2 == evlist__nr_groups(evlist), evlist);
1029
1030	evlist__for_each_entry(evlist, evsel) {
1031		if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
1032			/* group1 syscalls:sys_enter_openat:H */
1033			group1_leader = evsel;
1034			TEST_ASSERT_EVSEL("wrong sample_type",
1035					  evsel->core.attr.sample_type == PERF_TP_SAMPLE_TYPE,
1036					  evsel);
1037			TEST_ASSERT_EVSEL("wrong sample_period",
1038					  1 == evsel->core.attr.sample_period,
1039					  evsel);
1040			TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user,
1041					  evsel);
1042			TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel,
1043					  evsel);
1044			TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1045			TEST_ASSERT_EVSEL("wrong exclude guest", evsel->core.attr.exclude_guest,
1046					  evsel);
1047			TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host,
1048					  evsel);
1049			TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1050			TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1051			TEST_ASSERT_EVSEL("wrong group name", !strcmp(evsel->group_name, "group1"),
1052					  evsel);
1053			TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2,
1054					  evsel);
1055			TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1056			TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1057			continue;
1058		}
1059		if (evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
1060			if (evsel->core.attr.exclude_user) {
1061				/* group1 cycles:kppp */
1062				TEST_ASSERT_EVSEL("wrong exclude_user",
1063						  evsel->core.attr.exclude_user, evsel);
1064				TEST_ASSERT_EVSEL("wrong exclude_kernel",
1065						  !evsel->core.attr.exclude_kernel, evsel);
1066				TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv,
1067						  evsel);
1068				TEST_ASSERT_EVSEL("wrong exclude guest",
1069						  !evsel->core.attr.exclude_guest, evsel);
1070				TEST_ASSERT_EVSEL("wrong exclude host",
1071						  !evsel->core.attr.exclude_host, evsel);
1072				TEST_ASSERT_EVSEL("wrong precise_ip",
1073						  evsel->core.attr.precise_ip == 3, evsel);
1074				if (evsel__has_leader(evsel, group1_leader)) {
1075					TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name,
1076							  evsel);
1077					TEST_ASSERT_EVSEL("wrong group_idx",
1078							  evsel__group_idx(evsel) == 1,
1079							  evsel);
1080				}
1081				TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1082			} else {
1083				/* group2 cycles + G modifier */
1084				group2_leader = evsel;
1085				TEST_ASSERT_EVSEL("wrong exclude_kernel",
1086						  !evsel->core.attr.exclude_kernel, evsel);
1087				TEST_ASSERT_EVSEL("wrong exclude_hv",
1088						  !evsel->core.attr.exclude_hv, evsel);
1089				TEST_ASSERT_EVSEL("wrong exclude guest",
1090						  !evsel->core.attr.exclude_guest, evsel);
1091				TEST_ASSERT_EVSEL("wrong exclude host",
1092						  evsel->core.attr.exclude_host, evsel);
1093				TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip,
1094						  evsel);
1095				TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel),
1096						  evsel);
1097				if (evsel->core.nr_members == 2) {
1098					TEST_ASSERT_EVSEL("wrong group_idx",
1099							  evsel__group_idx(evsel) == 0,
1100							  evsel);
1101				}
1102				TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1103			}
1104			continue;
1105		}
1106		if (evsel->core.attr.type == 1) {
1107			/* group2 1:3 + G modifier */
1108			TEST_ASSERT_EVSEL("wrong config", 3 == evsel->core.attr.config, evsel);
1109			TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user,
1110					  evsel);
1111			TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel,
1112					  evsel);
1113			TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1114			TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest,
1115					  evsel);
1116			TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host,
1117					  evsel);
1118			TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1119			if (evsel__has_leader(evsel, group2_leader)) {
1120				TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1,
1121						  evsel);
1122			}
1123			TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1124			continue;
1125		}
1126		/* instructions:u */
1127		TEST_ASSERT_EVSEL("unexpected event",
1128				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1129				  evsel);
1130		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1131		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1132		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1133		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1134		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1135		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1136		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1137		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1138	}
1139	return TEST_OK;
1140}
1141
1142static int test__group4(struct evlist *evlist __maybe_unused)
1143{
1144	struct evsel *evsel = NULL, *leader;
1145
1146	TEST_ASSERT_EVLIST("wrong number of entries",
1147			   evlist->core.nr_entries == (num_core_entries(evlist) * 2),
1148			   evlist);
1149	TEST_ASSERT_EVLIST("wrong number of groups",
1150			   num_core_entries(evlist) == evlist__nr_groups(evlist),
1151			   evlist);
1152
1153	for (int i = 0; i < num_core_entries(evlist); i++) {
1154		/* cycles:u + p */
1155		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1156		TEST_ASSERT_EVSEL("unexpected event",
1157				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1158				  evsel);
1159		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1160		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1161		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1162		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1163		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1164		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip == 1, evsel);
1165		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1166		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1167		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1168		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1169		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1170
1171		/* instructions:kp + p */
1172		evsel = evsel__next(evsel);
1173		TEST_ASSERT_EVSEL("unexpected event",
1174				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1175				  evsel);
1176		TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
1177		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1178		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1179		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1180		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1181		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip == 2, evsel);
1182		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1183		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1184		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1185	}
1186	return TEST_OK;
1187}
1188
1189static int test__group5(struct evlist *evlist __maybe_unused)
1190{
1191	struct evsel *evsel = NULL, *leader;
1192
1193	TEST_ASSERT_EVLIST("wrong number of entries",
1194			   evlist->core.nr_entries == (5 * num_core_entries(evlist)),
1195			   evlist);
1196	TEST_ASSERT_EVLIST("wrong number of groups",
1197			   evlist__nr_groups(evlist) == (2 * num_core_entries(evlist)),
1198			   evlist);
1199
1200	for (int i = 0; i < num_core_entries(evlist); i++) {
1201		/* cycles + G */
1202		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1203		TEST_ASSERT_EVSEL("unexpected event",
1204				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1205				  evsel);
1206		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1207		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1208		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1209		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1210		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1211		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1212		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1213		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1214		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1215		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1216		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1217
1218		/* instructions + G */
1219		evsel = evsel__next(evsel);
1220		TEST_ASSERT_EVSEL("unexpected event",
1221				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1222				  evsel);
1223		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1224		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1225		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1226		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1227		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1228		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1229		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1230		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1231		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1232	}
1233	for (int i = 0; i < num_core_entries(evlist); i++) {
1234		/* cycles:G */
1235		evsel = leader = evsel__next(evsel);
1236		TEST_ASSERT_EVSEL("unexpected event",
1237				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1238				  evsel);
1239		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1240		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1241		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1242		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1243		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1244		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1245		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1246		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1247		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1248		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1249		TEST_ASSERT_EVSEL("wrong sample_read", !evsel->sample_read, evsel);
1250
1251		/* instructions:G */
1252		evsel = evsel__next(evsel);
1253		TEST_ASSERT_EVSEL("unexpected event",
1254				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1255				evsel);
1256		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1257		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1258		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1259		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1260		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1261		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1262		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1263		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1264	}
1265	for (int i = 0; i < num_core_entries(evlist); i++) {
1266		/* cycles */
1267		evsel = evsel__next(evsel);
1268		TEST_ASSERT_EVSEL("unexpected event",
1269				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1270				  evsel);
1271		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1272		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1273		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1274		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1275		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1276		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1277		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1278	}
1279	return TEST_OK;
1280}
1281
1282static int test__group_gh1(struct evlist *evlist)
1283{
1284	struct evsel *evsel = NULL, *leader;
1285
1286	TEST_ASSERT_EVLIST("wrong number of entries",
1287			   evlist->core.nr_entries == (2 * num_core_entries(evlist)),
1288			   evlist);
1289	TEST_ASSERT_EVLIST("wrong number of groups",
1290			   evlist__nr_groups(evlist) == num_core_entries(evlist),
1291			   evlist);
1292
1293	for (int i = 0; i < num_core_entries(evlist); i++) {
1294		/* cycles + :H group modifier */
1295		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1296		TEST_ASSERT_EVSEL("unexpected event",
1297				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1298				  evsel);
1299		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1300		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1301		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1302		TEST_ASSERT_EVSEL("wrong exclude guest", evsel->core.attr.exclude_guest, evsel);
1303		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1304		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1305		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1306		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1307		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1308		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1309
1310		/* cache-misses:G + :H group modifier */
1311		evsel = evsel__next(evsel);
1312		TEST_ASSERT_EVSEL("unexpected event",
1313				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1314				  evsel);
1315		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1316		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1317		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1318		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1319		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1320		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1321		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1322		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1323	}
1324	return TEST_OK;
1325}
1326
1327static int test__group_gh2(struct evlist *evlist)
1328{
1329	struct evsel *evsel = NULL, *leader;
1330
1331	TEST_ASSERT_EVLIST("wrong number of entries",
1332			   evlist->core.nr_entries == (2 * num_core_entries(evlist)),
1333			   evlist);
1334	TEST_ASSERT_EVLIST("wrong number of groups",
1335			   evlist__nr_groups(evlist) == num_core_entries(evlist),
1336			   evlist);
1337
1338	for (int i = 0; i < num_core_entries(evlist); i++) {
1339		/* cycles + :G group modifier */
1340		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1341		TEST_ASSERT_EVSEL("unexpected event",
1342				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1343				  evsel);
1344		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1345		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1346		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1347		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1348		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1349		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1350		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1351		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1352		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1353		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1354
1355		/* cache-misses:H + :G group modifier */
1356		evsel = evsel__next(evsel);
1357		TEST_ASSERT_EVSEL("unexpected event",
1358				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1359				  evsel);
1360		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1361		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1362		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1363		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1364		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1365		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1366		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1367		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1368	}
1369	return TEST_OK;
1370}
1371
1372static int test__group_gh3(struct evlist *evlist)
1373{
1374	struct evsel *evsel = NULL, *leader;
1375
1376	TEST_ASSERT_EVLIST("wrong number of entries",
1377			   evlist->core.nr_entries == (2 * num_core_entries(evlist)),
1378			   evlist);
1379	TEST_ASSERT_EVLIST("wrong number of groups",
1380			   evlist__nr_groups(evlist) == num_core_entries(evlist),
1381			   evlist);
1382
1383	for (int i = 0; i < num_core_entries(evlist); i++) {
1384		/* cycles:G + :u group modifier */
1385		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1386		TEST_ASSERT_EVSEL("unexpected event",
1387				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1388				  evsel);
1389		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1390		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1391		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1392		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1393		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1394		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1395		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1396		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1397		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1398		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1399
1400		/* cache-misses:H + :u group modifier */
1401		evsel = evsel__next(evsel);
1402		TEST_ASSERT_EVSEL("unexpected event",
1403				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1404				  evsel);
1405		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1406		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1407		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1408		TEST_ASSERT_EVSEL("wrong exclude guest", evsel->core.attr.exclude_guest, evsel);
1409		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1410		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1411		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1412		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1413	}
1414	return TEST_OK;
1415}
1416
1417static int test__group_gh4(struct evlist *evlist)
1418{
1419	struct evsel *evsel = NULL, *leader;
1420
1421	TEST_ASSERT_EVLIST("wrong number of entries",
1422			   evlist->core.nr_entries == (2 * num_core_entries(evlist)),
1423			   evlist);
1424	TEST_ASSERT_EVLIST("wrong number of groups",
1425			   evlist__nr_groups(evlist) == num_core_entries(evlist),
1426			   evlist);
1427
1428	for (int i = 0; i < num_core_entries(evlist); i++) {
1429		/* cycles:G + :uG group modifier */
1430		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1431		TEST_ASSERT_EVSEL("unexpected event",
1432				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1433				  evsel);
1434		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1435		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1436		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1437		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1438		TEST_ASSERT_EVSEL("wrong exclude host", evsel->core.attr.exclude_host, evsel);
1439		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1440		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1441		TEST_ASSERT_EVSEL("wrong leader", evsel__is_group_leader(evsel), evsel);
1442		TEST_ASSERT_EVSEL("wrong core.nr_members", evsel->core.nr_members == 2, evsel);
1443		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 0, evsel);
1444
1445		/* cache-misses:H + :uG group modifier */
1446		evsel = evsel__next(evsel);
1447		TEST_ASSERT_EVSEL("unexpected event",
1448				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1449				  evsel);
1450		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1451		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1452		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1453		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1454		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1455		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1456		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1457		TEST_ASSERT_EVSEL("wrong group_idx", evsel__group_idx(evsel) == 1, evsel);
1458	}
1459	return TEST_OK;
1460}
1461
1462static int test__leader_sample1(struct evlist *evlist)
1463{
1464	struct evsel *evsel = NULL, *leader;
1465
1466	TEST_ASSERT_EVLIST("wrong number of entries",
1467			   evlist->core.nr_entries == (3 * num_core_entries(evlist)),
1468			   evlist);
1469
1470	for (int i = 0; i < num_core_entries(evlist); i++) {
1471		/* cycles - sampling group leader */
1472		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1473		TEST_ASSERT_EVSEL("unexpected event",
1474				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1475				  evsel);
1476		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1477		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1478		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1479		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1480		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1481		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1482		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1483		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1484		TEST_ASSERT_EVSEL("wrong sample_read", evsel->sample_read, evsel);
1485
1486		/* cache-misses - not sampling */
1487		evsel = evsel__next(evsel);
1488		TEST_ASSERT_EVSEL("unexpected event",
1489				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1490				  evsel);
1491		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1492		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1493		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1494		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1495		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1496		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1497		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1498		TEST_ASSERT_EVSEL("wrong sample_read", evsel->sample_read, evsel);
1499
1500		/* branch-misses - not sampling */
1501		evsel = evsel__next(evsel);
1502		TEST_ASSERT_EVSEL("unexpected event",
1503				  evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES),
1504				  evsel);
1505		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1506		TEST_ASSERT_EVSEL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel, evsel);
1507		TEST_ASSERT_EVSEL("wrong exclude_hv", !evsel->core.attr.exclude_hv, evsel);
1508		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1509		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1510		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1511		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1512		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1513		TEST_ASSERT_EVSEL("wrong sample_read", evsel->sample_read, evsel);
1514	}
1515	return TEST_OK;
1516}
1517
1518static int test__leader_sample2(struct evlist *evlist __maybe_unused)
1519{
1520	struct evsel *evsel = NULL, *leader;
1521
1522	TEST_ASSERT_EVLIST("wrong number of entries",
1523			   evlist->core.nr_entries == (2 * num_core_entries(evlist)),
1524			   evlist);
1525
1526	for (int i = 0; i < num_core_entries(evlist); i++) {
1527		/* instructions - sampling group leader */
1528		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1529		TEST_ASSERT_EVSEL("unexpected event",
1530				  evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1531				  evsel);
1532		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1533		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1534		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1535		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1536		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1537		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1538		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1539		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1540		TEST_ASSERT_EVSEL("wrong sample_read", evsel->sample_read, evsel);
1541
1542		/* branch-misses - not sampling */
1543		evsel = evsel__next(evsel);
1544		TEST_ASSERT_EVSEL("unexpected event",
1545				  evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES),
1546				  evsel);
1547		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1548		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1549		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1550		TEST_ASSERT_EVSEL("wrong exclude guest", !evsel->core.attr.exclude_guest, evsel);
1551		TEST_ASSERT_EVSEL("wrong exclude host", !evsel->core.attr.exclude_host, evsel);
1552		TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1553		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1554		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1555		TEST_ASSERT_EVSEL("wrong sample_read", evsel->sample_read, evsel);
1556	}
1557	return TEST_OK;
1558}
1559
1560static int test__checkevent_pinned_modifier(struct evlist *evlist)
1561{
1562	struct evsel *evsel = NULL;
1563
1564	TEST_ASSERT_EVLIST("wrong number of entries",
1565			   evlist->core.nr_entries == num_core_entries(evlist),
1566			   evlist);
1567
1568	for (int i = 0; i < num_core_entries(evlist); i++) {
1569		evsel = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1570		TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1571		TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1572		TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1573		TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
1574		TEST_ASSERT_EVSEL("wrong pinned", evsel->core.attr.pinned, evsel);
1575	}
1576	return test__checkevent_symbolic_name(evlist);
1577}
1578
1579static int test__pinned_group(struct evlist *evlist)
1580{
1581	struct evsel *evsel = NULL, *leader;
1582
1583	TEST_ASSERT_EVLIST("wrong number of entries",
1584			   evlist->core.nr_entries == (3 * num_core_entries(evlist)),
1585			   evlist);
1586
1587	for (int i = 0; i < num_core_entries(evlist); i++) {
1588		/* cycles - group leader */
1589		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1590		TEST_ASSERT_EVSEL("unexpected event",
1591				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1592				evsel);
1593		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1594		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1595		/* TODO: The group modifier is not copied to the split group leader. */
1596		if (perf_pmus__num_core_pmus() == 1)
1597			TEST_ASSERT_EVSEL("wrong pinned", evsel->core.attr.pinned, evsel);
1598
1599		/* cache-misses - can not be pinned, but will go on with the leader */
1600		evsel = evsel__next(evsel);
1601		TEST_ASSERT_EVSEL("unexpected event",
1602				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1603				  evsel);
1604		TEST_ASSERT_EVSEL("wrong pinned", !evsel->core.attr.pinned, evsel);
1605
1606		/* branch-misses - ditto */
1607		evsel = evsel__next(evsel);
1608		TEST_ASSERT_EVSEL("unexpected event",
1609				  evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES),
1610				  evsel);
1611		TEST_ASSERT_EVSEL("wrong pinned", !evsel->core.attr.pinned, evsel);
1612	}
1613	return TEST_OK;
1614}
1615
1616static int test__checkevent_exclusive_modifier(struct evlist *evlist)
1617{
1618	struct evsel *evsel = evlist__first(evlist);
1619
1620	TEST_ASSERT_EVLIST("wrong number of entries",
1621			   evlist->core.nr_entries == num_core_entries(evlist),
1622			   evlist);
1623	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1624	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1625	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1626	TEST_ASSERT_EVSEL("wrong precise_ip", evsel->core.attr.precise_ip, evsel);
1627	TEST_ASSERT_EVSEL("wrong exclusive", evsel->core.attr.exclusive, evsel);
1628
1629	return test__checkevent_symbolic_name(evlist);
1630}
1631
1632static int test__exclusive_group(struct evlist *evlist)
1633{
1634	struct evsel *evsel = NULL, *leader;
1635
1636	TEST_ASSERT_EVLIST("wrong number of entries",
1637			   evlist->core.nr_entries == 3 * num_core_entries(evlist),
1638			   evlist);
1639
1640	for (int i = 0; i < num_core_entries(evlist); i++) {
1641		/* cycles - group leader */
1642		evsel = leader = (i == 0 ? evlist__first(evlist) : evsel__next(evsel));
1643		TEST_ASSERT_EVSEL("unexpected event",
1644				  evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1645				  evsel);
1646		TEST_ASSERT_EVSEL("wrong group name", !evsel->group_name, evsel);
1647		TEST_ASSERT_EVSEL("wrong leader", evsel__has_leader(evsel, leader), evsel);
1648		/* TODO: The group modifier is not copied to the split group leader. */
1649		if (perf_pmus__num_core_pmus() == 1)
1650			TEST_ASSERT_EVSEL("wrong exclusive", evsel->core.attr.exclusive, evsel);
1651
1652		/* cache-misses - can not be pinned, but will go on with the leader */
1653		evsel = evsel__next(evsel);
1654		TEST_ASSERT_EVSEL("unexpected event",
1655				  evsel__match(evsel, HARDWARE, HW_CACHE_MISSES),
1656				  evsel);
1657		TEST_ASSERT_EVSEL("wrong exclusive", !evsel->core.attr.exclusive, evsel);
1658
1659		/* branch-misses - ditto */
1660		evsel = evsel__next(evsel);
1661		TEST_ASSERT_EVSEL("unexpected event",
1662				  evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES),
1663				  evsel);
1664		TEST_ASSERT_EVSEL("wrong exclusive", !evsel->core.attr.exclusive, evsel);
1665	}
1666	return TEST_OK;
1667}
1668static int test__checkevent_breakpoint_len(struct evlist *evlist)
1669{
1670	struct evsel *evsel = evlist__first(evlist);
1671
1672	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1673	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
1674	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
1675	TEST_ASSERT_EVSEL("wrong bp_type",
1676			  (HW_BREAKPOINT_R | HW_BREAKPOINT_W) == evsel->core.attr.bp_type,
1677			  evsel);
1678	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_1 == evsel->core.attr.bp_len, evsel);
1679
1680	return TEST_OK;
1681}
1682
1683static int test__checkevent_breakpoint_len_w(struct evlist *evlist)
1684{
1685	struct evsel *evsel = evlist__first(evlist);
1686
1687	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1688	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type, evsel);
1689	TEST_ASSERT_EVSEL("wrong config", 0 == evsel->core.attr.config, evsel);
1690	TEST_ASSERT_EVSEL("wrong bp_type", HW_BREAKPOINT_W == evsel->core.attr.bp_type, evsel);
1691	TEST_ASSERT_EVSEL("wrong bp_len", HW_BREAKPOINT_LEN_2 == evsel->core.attr.bp_len, evsel);
1692
1693	return TEST_OK;
1694}
1695
1696static int
1697test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist)
1698{
1699	struct evsel *evsel = evlist__first(evlist);
1700
1701	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1702	TEST_ASSERT_EVSEL("wrong exclude_user", !evsel->core.attr.exclude_user, evsel);
1703	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1704	TEST_ASSERT_EVSEL("wrong exclude_hv", evsel->core.attr.exclude_hv, evsel);
1705	TEST_ASSERT_EVSEL("wrong precise_ip", !evsel->core.attr.precise_ip, evsel);
1706
1707	return test__checkevent_breakpoint_rw(evlist);
1708}
1709
1710static int test__checkevent_precise_max_modifier(struct evlist *evlist)
1711{
1712	struct evsel *evsel = evlist__first(evlist);
1713
1714	TEST_ASSERT_EVLIST("wrong number of entries",
1715			   evlist->core.nr_entries == 1 + num_core_entries(evlist),
1716			   evlist);
1717	TEST_ASSERT_EVSEL("wrong type/config", evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK), evsel);
1718	return TEST_OK;
1719}
1720
1721static int test__checkevent_config_symbol(struct evlist *evlist)
1722{
1723	struct evsel *evsel = evlist__first(evlist);
1724
1725	TEST_ASSERT_EVLIST("wrong number of entries",
1726			   evlist->core.nr_entries == num_core_entries(evlist),
1727			   evlist);
1728	TEST_ASSERT_EVSEL("wrong name setting", evsel__name_is(evsel, "insn"), evsel);
1729	return TEST_OK;
1730}
1731
1732static int test__checkevent_config_raw(struct evlist *evlist)
1733{
1734	struct evsel *evsel = evlist__first(evlist);
1735
1736	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1737	TEST_ASSERT_EVSEL("wrong name setting", evsel__name_is(evsel, "rawpmu"), evsel);
1738	return TEST_OK;
1739}
1740
1741static int test__checkevent_config_num(struct evlist *evlist)
1742{
1743	struct evsel *evsel = evlist__first(evlist);
1744
1745	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1746	TEST_ASSERT_EVSEL("wrong name setting", evsel__name_is(evsel, "numpmu"), evsel);
1747	return TEST_OK;
1748}
1749
1750static int test__checkevent_config_cache(struct evlist *evlist)
1751{
1752	struct evsel *evsel = evlist__first(evlist);
1753
1754	TEST_ASSERT_EVLIST("wrong number of entries",
1755			   evlist->core.nr_entries == num_core_entries(evlist),
1756			   evlist);
1757	TEST_ASSERT_EVSEL("wrong name setting", evsel__name_is(evsel, "cachepmu"), evsel);
1758	return test__checkevent_genhw(evlist);
1759}
1760
1761static bool test__pmu_default_core_event_valid(void)
1762{
1763	struct perf_pmu *pmu = perf_pmus__find_core_pmu();
1764
1765	if (!pmu)
1766		return false;
1767
1768	return perf_pmu__has_format(pmu, "event");
1769}
1770
1771static bool test__intel_pt_valid(void)
1772{
1773	return !!perf_pmus__find("intel_pt");
1774}
1775
1776static int test__intel_pt(struct evlist *evlist)
1777{
1778	struct evsel *evsel = evlist__first(evlist);
1779
1780	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1781	TEST_ASSERT_EVSEL("wrong name setting", evsel__name_is(evsel, "intel_pt//u"), evsel);
1782	return TEST_OK;
1783}
1784
1785static bool test__acr_valid(void)
1786{
1787	struct perf_pmu *pmu = NULL;
1788
1789	while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
1790		if (perf_pmu__has_format(pmu, "acr_mask"))
1791			return true;
1792	}
1793
1794	return false;
1795}
1796
1797static int test__ratio_to_prev(struct evlist *evlist)
1798{
1799	struct evsel *evsel;
1800
1801	TEST_ASSERT_VAL("wrong number of entries", 2 * perf_pmus__num_core_pmus() == evlist->core.nr_entries);
1802
1803	 evlist__for_each_entry(evlist, evsel) {
1804		if (!perf_pmu__has_format(evsel->pmu, "acr_mask"))
1805			return TEST_OK;
1806
1807		if (evsel == evlist__first(evlist)) {
1808			TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2);
1809			TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1810			TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1811			TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1812			TEST_ASSERT_EVSEL("unexpected event",
1813					evsel__match(evsel, HARDWARE, HW_CPU_CYCLES),
1814					evsel);
1815		} else {
1816			TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2);
1817			TEST_ASSERT_VAL("wrong leader", !evsel__is_group_leader(evsel));
1818			TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 0);
1819			TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1820			TEST_ASSERT_EVSEL("unexpected event",
1821					evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS),
1822					evsel);
1823		}
1824		/*
1825		 * The period value gets configured within evlist__config,
1826		 * while this test executes only parse events method.
1827		 */
1828		TEST_ASSERT_VAL("wrong period", 0 == evsel->core.attr.sample_period);
1829	}
1830	return TEST_OK;
1831}
1832
1833static int test__checkevent_complex_name(struct evlist *evlist)
1834{
1835	struct evsel *evsel = evlist__first(evlist);
1836
1837	TEST_ASSERT_EVLIST("wrong number of entries",
1838			   evlist->core.nr_entries == num_core_entries(evlist),
1839			   evlist);
1840	TEST_ASSERT_EVSEL("wrong complex name parsing",
1841			  evsel__name_is(evsel,
1842				  "COMPLEX_CYCLES_NAME:orig=cpu-cycles,desc=chip-clock-ticks"),
1843			  evsel);
1844	return TEST_OK;
1845}
1846
1847static int test__checkevent_raw_pmu(struct evlist *evlist)
1848{
1849	struct evsel *evsel = evlist__first(evlist);
1850
1851	TEST_ASSERT_EVLIST("wrong number of entries", 1 == evlist->core.nr_entries, evlist);
1852	TEST_ASSERT_EVSEL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type, evsel);
1853	TEST_ASSERT_EVSEL("wrong config", 0x1a == evsel->core.attr.config, evsel);
1854	return TEST_OK;
1855}
1856
1857static int test__sym_event_slash(struct evlist *evlist)
1858{
1859	struct evsel *evsel = evlist__first(evlist);
1860
1861	TEST_ASSERT_EVLIST("wrong number of entries",
1862			   evlist->core.nr_entries == num_core_entries(evlist),
1863			   evlist);
1864	TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES), evsel);
1865	TEST_ASSERT_EVSEL("wrong exclude_kernel", evsel->core.attr.exclude_kernel, evsel);
1866	return TEST_OK;
1867}
1868
1869static int test__sym_event_dc(struct evlist *evlist)
1870{
1871	struct evsel *evsel = evlist__first(evlist);
1872
1873	TEST_ASSERT_EVLIST("wrong number of entries",
1874			   evlist->core.nr_entries == num_core_entries(evlist),
1875			   evlist);
1876	TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES), evsel);
1877	TEST_ASSERT_EVSEL("wrong exclude_user", evsel->core.attr.exclude_user, evsel);
1878	return TEST_OK;
1879}
1880
1881static int test__term_equal_term(struct evlist *evlist)
1882{
1883	struct evsel *evsel = evlist__first(evlist);
1884
1885	TEST_ASSERT_EVLIST("wrong number of entries",
1886			   evlist->core.nr_entries == num_core_entries(evlist),
1887			   evlist);
1888	TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES), evsel);
1889	TEST_ASSERT_EVSEL("wrong name setting", strcmp(evsel->name, "name") == 0, evsel);
1890	return TEST_OK;
1891}
1892
1893static int test__term_equal_legacy(struct evlist *evlist)
1894{
1895	struct evsel *evsel = evlist__first(evlist);
1896
1897	TEST_ASSERT_EVLIST("wrong number of entries",
1898			   evlist->core.nr_entries == num_core_entries(evlist),
1899			   evlist);
1900	TEST_ASSERT_EVSEL("unexpected event", evsel__match(evsel, HARDWARE, HW_CPU_CYCLES), evsel);
1901	TEST_ASSERT_EVSEL("wrong name setting", strcmp(evsel->name, "l1d") == 0, evsel);
1902	return TEST_OK;
1903}
1904
1905static int count_tracepoints(void)
1906{
1907	struct dirent *events_ent;
1908	DIR *events_dir;
1909	int cnt = 0;
1910
1911	events_dir = tracing_events__opendir();
1912
1913	TEST_ASSERT_VAL("Can't open events dir", events_dir);
1914
1915	while ((events_ent = readdir(events_dir))) {
1916		char *sys_path;
1917		struct dirent *sys_ent;
1918		DIR *sys_dir;
1919
1920		if (!strcmp(events_ent->d_name, ".")
1921		    || !strcmp(events_ent->d_name, "..")
1922		    || !strcmp(events_ent->d_name, "enable")
1923		    || !strcmp(events_ent->d_name, "header_event")
1924		    || !strcmp(events_ent->d_name, "header_page"))
1925			continue;
1926
1927		sys_path = get_events_file(events_ent->d_name);
1928		TEST_ASSERT_VAL("Can't get sys path", sys_path);
1929
1930		sys_dir = opendir(sys_path);
1931		TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
1932
1933		while ((sys_ent = readdir(sys_dir))) {
1934			if (!strcmp(sys_ent->d_name, ".")
1935			    || !strcmp(sys_ent->d_name, "..")
1936			    || !strcmp(sys_ent->d_name, "enable")
1937			    || !strcmp(sys_ent->d_name, "filter"))
1938				continue;
1939
1940			cnt++;
1941		}
1942
1943		closedir(sys_dir);
1944		put_events_file(sys_path);
1945	}
1946
1947	closedir(events_dir);
1948	return cnt;
1949}
1950
1951static int test__all_tracepoints(struct evlist *evlist)
1952{
1953	TEST_ASSERT_VAL("wrong events count",
1954			count_tracepoints() == evlist->core.nr_entries);
1955
1956	return test__checkevent_tracepoint_multi(evlist);
1957}
1958
1959struct evlist_test {
1960	const char *name;
1961	bool (*valid)(void);
1962	int (*check)(struct evlist *evlist);
1963};
1964
1965static const struct evlist_test test__events[] = {
1966	{
1967		.name  = "syscalls:sys_enter_openat",
1968		.check = test__checkevent_tracepoint,
1969		/* 0 */
1970	},
1971	{
1972		.name  = "syscalls:*",
1973		.check = test__checkevent_tracepoint_multi,
1974		/* 1 */
1975	},
1976	{
1977		.name  = "r1a",
1978		.check = test__checkevent_raw,
1979		/* 2 */
1980	},
1981	{
1982		.name  = "1:1",
1983		.check = test__checkevent_numeric,
1984		/* 3 */
1985	},
1986	{
1987		.name  = "instructions",
1988		.check = test__checkevent_symbolic_name,
1989		/* 4 */
1990	},
1991	{
1992		.name  = "cpu-cycles/period=100000,config2/",
1993		.check = test__checkevent_symbolic_name_config,
1994		/* 5 */
1995	},
1996	{
1997		.name  = "faults",
1998		.check = test__checkevent_symbolic_alias,
1999		/* 6 */
2000	},
2001	{
2002		.name  = "L1-dcache-load-miss",
2003		.check = test__checkevent_genhw,
2004		/* 7 */
2005	},
2006	{
2007		.name  = "mem:0",
2008		.check = test__checkevent_breakpoint,
2009		/* 8 */
2010	},
2011	{
2012		.name  = "mem:0:x",
2013		.check = test__checkevent_breakpoint_x,
2014		/* 9 */
2015	},
2016	{
2017		.name  = "mem:0:r",
2018		.check = test__checkevent_breakpoint_r,
2019		/* 0 */
2020	},
2021	{
2022		.name  = "mem:0:w",
2023		.check = test__checkevent_breakpoint_w,
2024		/* 1 */
2025	},
2026	{
2027		.name  = "syscalls:sys_enter_openat:k",
2028		.check = test__checkevent_tracepoint_modifier,
2029		/* 2 */
2030	},
2031	{
2032		.name  = "syscalls:*:u",
2033		.check = test__checkevent_tracepoint_multi_modifier,
2034		/* 3 */
2035	},
2036	{
2037		.name  = "r1a:kp",
2038		.check = test__checkevent_raw_modifier,
2039		/* 4 */
2040	},
2041	{
2042		.name  = "1:1:hp",
2043		.check = test__checkevent_numeric_modifier,
2044		/* 5 */
2045	},
2046	{
2047		.name  = "instructions:h",
2048		.check = test__checkevent_symbolic_name_modifier,
2049		/* 6 */
2050	},
2051	{
2052		.name  = "faults:u",
2053		.check = test__checkevent_symbolic_alias_modifier,
2054		/* 7 */
2055	},
2056	{
2057		.name  = "L1-dcache-load-miss:kp",
2058		.check = test__checkevent_genhw_modifier,
2059		/* 8 */
2060	},
2061	{
2062		.name  = "mem:0:u",
2063		.check = test__checkevent_breakpoint_modifier,
2064		/* 9 */
2065	},
2066	{
2067		.name  = "mem:0:x:k",
2068		.check = test__checkevent_breakpoint_x_modifier,
2069		/* 0 */
2070	},
2071	{
2072		.name  = "mem:0:r:hp",
2073		.check = test__checkevent_breakpoint_r_modifier,
2074		/* 1 */
2075	},
2076	{
2077		.name  = "mem:0:w:up",
2078		.check = test__checkevent_breakpoint_w_modifier,
2079		/* 2 */
2080	},
2081	{
2082		.name  = "r1,syscalls:sys_enter_openat:k,1:1:hp",
2083		.check = test__checkevent_list,
2084		/* 3 */
2085	},
2086	{
2087		.name  = "instructions:G",
2088		.check = test__checkevent_exclude_host_modifier,
2089		/* 4 */
2090	},
2091	{
2092		.name  = "instructions:H",
2093		.check = test__checkevent_exclude_guest_modifier,
2094		/* 5 */
2095	},
2096	{
2097		.name  = "mem:0:rw",
2098		.check = test__checkevent_breakpoint_rw,
2099		/* 6 */
2100	},
2101	{
2102		.name  = "mem:0:rw:kp",
2103		.check = test__checkevent_breakpoint_rw_modifier,
2104		/* 7 */
2105	},
2106	{
2107		.name  = "{instructions:k,cpu-cycles:upp}",
2108		.check = test__group1,
2109		/* 8 */
2110	},
2111	{
2112		.name  = "{faults:k,branches}:u,cpu-cycles:k",
2113		.check = test__group2,
2114		/* 9 */
2115	},
2116	{
2117		.name  = "group1{syscalls:sys_enter_openat:H,cpu-cycles:kppp},group2{cpu-cycles,1:3}:G,instructions:u",
2118		.check = test__group3,
2119		/* 0 */
2120	},
2121	{
2122		.name  = "{cpu-cycles:u,instructions:kp}:p",
2123		.check = test__group4,
2124		/* 1 */
2125	},
2126	{
2127		.name  = "{cpu-cycles,instructions}:G,{cpu-cycles:G,instructions:G},cpu-cycles",
2128		.check = test__group5,
2129		/* 2 */
2130	},
2131	{
2132		.name  = "*:*",
2133		.check = test__all_tracepoints,
2134		/* 3 */
2135	},
2136	{
2137		.name  = "{cpu-cycles,cache-misses:G}:H",
2138		.check = test__group_gh1,
2139		/* 4 */
2140	},
2141	{
2142		.name  = "{cpu-cycles,cache-misses:H}:G",
2143		.check = test__group_gh2,
2144		/* 5 */
2145	},
2146	{
2147		.name  = "{cpu-cycles:G,cache-misses:H}:u",
2148		.check = test__group_gh3,
2149		/* 6 */
2150	},
2151	{
2152		.name  = "{cpu-cycles:G,cache-misses:H}:uG",
2153		.check = test__group_gh4,
2154		/* 7 */
2155	},
2156	{
2157		.name  = "{cpu-cycles,cache-misses,branch-misses}:S",
2158		.check = test__leader_sample1,
2159		/* 8 */
2160	},
2161	{
2162		.name  = "{instructions,branch-misses}:Su",
2163		.check = test__leader_sample2,
2164		/* 9 */
2165	},
2166	{
2167		.name  = "instructions:uDp",
2168		.check = test__checkevent_pinned_modifier,
2169		/* 0 */
2170	},
2171	{
2172		.name  = "{cpu-cycles,cache-misses,branch-misses}:D",
2173		.check = test__pinned_group,
2174		/* 1 */
2175	},
2176	{
2177		.name  = "mem:0/1",
2178		.check = test__checkevent_breakpoint_len,
2179		/* 2 */
2180	},
2181	{
2182		.name  = "mem:0/2:w",
2183		.check = test__checkevent_breakpoint_len_w,
2184		/* 3 */
2185	},
2186	{
2187		.name  = "mem:0/4:rw:u",
2188		.check = test__checkevent_breakpoint_len_rw_modifier,
2189		/* 4 */
2190	},
2191#if defined(__s390x__)
2192	{
2193		.name  = "kvm-s390:kvm_s390_create_vm",
2194		.check = test__checkevent_tracepoint,
2195		.valid = kvm_s390_create_vm_valid,
2196		/* 0 */
2197	},
2198#endif
2199	{
2200		.name  = "instructions:I",
2201		.check = test__checkevent_exclude_idle_modifier,
2202		/* 5 */
2203	},
2204	{
2205		.name  = "instructions:kIG",
2206		.check = test__checkevent_exclude_idle_modifier_1,
2207		/* 6 */
2208	},
2209	{
2210		.name  = "task-clock:P,cpu-cycles",
2211		.check = test__checkevent_precise_max_modifier,
2212		/* 7 */
2213	},
2214	{
2215		.name  = "instructions/name=insn/",
2216		.check = test__checkevent_config_symbol,
2217		/* 8 */
2218	},
2219	{
2220		.name  = "r1234/name=rawpmu/",
2221		.check = test__checkevent_config_raw,
2222		/* 9 */
2223	},
2224	{
2225		.name  = "4:0x6530160/name=numpmu/",
2226		.check = test__checkevent_config_num,
2227		/* 0 */
2228	},
2229	{
2230		.name  = "L1-dcache-misses/name=cachepmu/",
2231		.check = test__checkevent_config_cache,
2232		/* 1 */
2233	},
2234	{
2235		.name  = "intel_pt//u",
2236		.valid = test__intel_pt_valid,
2237		.check = test__intel_pt,
2238		/* 2 */
2239	},
2240	{
2241		.name  = "cpu-cycles/name='COMPLEX_CYCLES_NAME:orig=cpu-cycles,desc=chip-clock-ticks'/Duk",
2242		.check = test__checkevent_complex_name,
2243		/* 3 */
2244	},
2245	{
2246		.name  = "cpu-cycles//u",
2247		.check = test__sym_event_slash,
2248		/* 4 */
2249	},
2250	{
2251		.name  = "cpu-cycles:k",
2252		.check = test__sym_event_dc,
2253		/* 5 */
2254	},
2255	{
2256		.name  = "instructions:uep",
2257		.check = test__checkevent_exclusive_modifier,
2258		/* 6 */
2259	},
2260	{
2261		.name  = "{cpu-cycles,cache-misses,branch-misses}:e",
2262		.check = test__exclusive_group,
2263		/* 7 */
2264	},
2265	{
2266		.name  = "cpu-cycles/name=name/",
2267		.check = test__term_equal_term,
2268		/* 8 */
2269	},
2270	{
2271		.name  = "cpu-cycles/name=l1d/",
2272		.check = test__term_equal_legacy,
2273		/* 9 */
2274	},
2275	{
2276		.name  = "mem:0/name=breakpoint/",
2277		.check = test__checkevent_breakpoint,
2278		/* 0 */
2279	},
2280	{
2281		.name  = "mem:0:x/name=breakpoint/",
2282		.check = test__checkevent_breakpoint_x,
2283		/* 1 */
2284	},
2285	{
2286		.name  = "mem:0:r/name=breakpoint/",
2287		.check = test__checkevent_breakpoint_r,
2288		/* 2 */
2289	},
2290	{
2291		.name  = "mem:0:w/name=breakpoint/",
2292		.check = test__checkevent_breakpoint_w,
2293		/* 3 */
2294	},
2295	{
2296		.name  = "mem:0/name=breakpoint/u",
2297		.check = test__checkevent_breakpoint_modifier_name,
2298		/* 4 */
2299	},
2300	{
2301		.name  = "mem:0:x/name=breakpoint/k",
2302		.check = test__checkevent_breakpoint_x_modifier_name,
2303		/* 5 */
2304	},
2305	{
2306		.name  = "mem:0:r/name=breakpoint/hp",
2307		.check = test__checkevent_breakpoint_r_modifier_name,
2308		/* 6 */
2309	},
2310	{
2311		.name  = "mem:0:w/name=breakpoint/up",
2312		.check = test__checkevent_breakpoint_w_modifier_name,
2313		/* 7 */
2314	},
2315	{
2316		.name  = "mem:0:rw/name=breakpoint/",
2317		.check = test__checkevent_breakpoint_rw,
2318		/* 8 */
2319	},
2320	{
2321		.name  = "mem:0:rw/name=breakpoint/kp",
2322		.check = test__checkevent_breakpoint_rw_modifier_name,
2323		/* 9 */
2324	},
2325	{
2326		.name  = "mem:0/1/name=breakpoint/",
2327		.check = test__checkevent_breakpoint_len,
2328		/* 0 */
2329	},
2330	{
2331		.name  = "mem:0/2:w/name=breakpoint/",
2332		.check = test__checkevent_breakpoint_len_w,
2333		/* 1 */
2334	},
2335	{
2336		.name  = "mem:0/4:rw/name=breakpoint/u",
2337		.check = test__checkevent_breakpoint_len_rw_modifier,
2338		/* 2 */
2339	},
2340	{
2341		.name  = "mem:0/1/name=breakpoint1/,mem:0/4:rw/name=breakpoint2/",
2342		.check = test__checkevent_breakpoint_2_events,
2343		/* 3 */
2344	},
2345	{
2346		.name = "9p:9p_client_req",
2347		.check = test__checkevent_tracepoint,
2348		/* 4 */
2349	},
2350	{
2351		.name  = "{cycles,instructions/period=200000,ratio-to-prev=2.0/}",
2352		.valid = test__acr_valid,
2353		.check = test__ratio_to_prev,
2354		/* 5 */
2355	},
2356
2357};
2358
2359static const struct evlist_test test__events_pmu[] = {
2360	{
2361		.name  = "default_core/config=10,config1=1,config2=3,period=1000/u",
2362		.check = test__checkevent_pmu,
2363		/* 0 */
2364	},
2365	{
2366		.name  = "default_core/config=1,name=krava/u,default_core/config=2/u",
2367		.check = test__checkevent_pmu_name,
2368		/* 1 */
2369	},
2370	{
2371		.name  = "default_core/config=1,call-graph=fp,time,period=100000/,default_core/config=2,call-graph=no,time=0,period=2000/",
2372		.check = test__checkevent_pmu_partial_time_callgraph,
2373		/* 2 */
2374	},
2375	{
2376		.name  = "default_core/name='COMPLEX_CYCLES_NAME:orig=cpu-cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp",
2377		.valid = test__pmu_default_core_event_valid,
2378		.check = test__checkevent_complex_name,
2379		/* 3 */
2380	},
2381	{
2382		.name  = "software/r1a/",
2383		.check = test__checkevent_raw_pmu,
2384		/* 4 */
2385	},
2386	{
2387		.name  = "software/r0x1a/",
2388		.check = test__checkevent_raw_pmu,
2389		/* 5 */
2390	},
2391	{
2392		.name  = "default_core/L1-dcache-load-miss/",
2393		.check = test__checkevent_genhw,
2394		/* 6 */
2395	},
2396	{
2397		.name  = "default_core/L1-dcache-load-miss/kp",
2398		.check = test__checkevent_genhw_modifier,
2399		/* 7 */
2400	},
2401	{
2402		.name  = "default_core/L1-dcache-misses,name=cachepmu/",
2403		.check = test__checkevent_config_cache,
2404		/* 8 */
2405	},
2406	{
2407		.name  = "default_core/instructions/",
2408		.check = test__checkevent_symbolic_name,
2409		/* 9 */
2410	},
2411	{
2412		.name  = "default_core/cycles,period=100000,config2/",
2413		.check = test__checkevent_symbolic_name_config,
2414		/* 0 */
2415	},
2416	{
2417		.name  = "default_core/instructions/h",
2418		.check = test__checkevent_symbolic_name_modifier,
2419		/* 1 */
2420	},
2421	{
2422		.name  = "default_core/instructions/G",
2423		.check = test__checkevent_exclude_host_modifier,
2424		/* 2 */
2425	},
2426	{
2427		.name  = "default_core/instructions/H",
2428		.check = test__checkevent_exclude_guest_modifier,
2429		/* 3 */
2430	},
2431	{
2432		.name  = "{default_core/instructions/k,default_core/cycles/upp}",
2433		.check = test__group1,
2434		/* 4 */
2435	},
2436	{
2437		.name  = "{default_core/cycles/u,default_core/instructions/kp}:p",
2438		.check = test__group4,
2439		/* 5 */
2440	},
2441	{
2442		.name  = "{default_core/cycles/,default_core/cache-misses/G}:H",
2443		.check = test__group_gh1,
2444		/* 6 */
2445	},
2446	{
2447		.name  = "{default_core/cycles/,default_core/cache-misses/H}:G",
2448		.check = test__group_gh2,
2449		/* 7 */
2450	},
2451	{
2452		.name  = "{default_core/cycles/G,default_core/cache-misses/H}:u",
2453		.check = test__group_gh3,
2454		/* 8 */
2455	},
2456	{
2457		.name  = "{default_core/cycles/G,default_core/cache-misses/H}:uG",
2458		.check = test__group_gh4,
2459		/* 9 */
2460	},
2461	{
2462		.name  = "{default_core/cycles/,default_core/cache-misses/,default_core/branch-misses/}:S",
2463		.check = test__leader_sample1,
2464		/* 0 */
2465	},
2466	{
2467		.name  = "{default_core/instructions/,default_core/branch-misses/}:Su",
2468		.check = test__leader_sample2,
2469		/* 1 */
2470	},
2471	{
2472		.name  = "default_core/instructions/uDp",
2473		.check = test__checkevent_pinned_modifier,
2474		/* 2 */
2475	},
2476	{
2477		.name  = "{default_core/cycles/,default_core/cache-misses/,default_core/branch-misses/}:D",
2478		.check = test__pinned_group,
2479		/* 3 */
2480	},
2481	{
2482		.name  = "default_core/instructions/I",
2483		.check = test__checkevent_exclude_idle_modifier,
2484		/* 4 */
2485	},
2486	{
2487		.name  = "default_core/instructions/kIG",
2488		.check = test__checkevent_exclude_idle_modifier_1,
2489		/* 5 */
2490	},
2491	{
2492		.name  = "default_core/cycles/u",
2493		.check = test__sym_event_slash,
2494		/* 6 */
2495	},
2496	{
2497		.name  = "default_core/cycles/k",
2498		.check = test__sym_event_dc,
2499		/* 7 */
2500	},
2501	{
2502		.name  = "default_core/instructions/uep",
2503		.check = test__checkevent_exclusive_modifier,
2504		/* 8 */
2505	},
2506	{
2507		.name  = "{default_core/cycles/,default_core/cache-misses/,default_core/branch-misses/}:e",
2508		.check = test__exclusive_group,
2509		/* 9 */
2510	},
2511	{
2512		.name  = "default_core/cycles,name=name/",
2513		.check = test__term_equal_term,
2514		/* 0 */
2515	},
2516	{
2517		.name  = "default_core/cycles,name=l1d/",
2518		.check = test__term_equal_legacy,
2519		/* 1 */
2520	},
2521};
2522
2523struct terms_test {
2524	const char *str;
2525	int (*check)(struct parse_events_terms *terms);
2526};
2527
2528static const struct terms_test test__terms[] = {
2529	[0] = {
2530		.str   = "config=10,config1,config2=3,config3=4,config4=5,umask=1,read,r0xead",
2531		.check = test__checkterms_simple,
2532	},
2533};
2534
2535static int test_event(const struct evlist_test *e)
2536{
2537	struct parse_events_error err;
2538	struct evlist *evlist;
2539	int ret;
2540
2541	if (e->valid && !e->valid()) {
2542		pr_debug("... SKIP\n");
2543		return TEST_OK;
2544	}
2545
2546	evlist = evlist__new();
2547	if (evlist == NULL) {
2548		pr_err("Failed allocation");
2549		return TEST_FAIL;
2550	}
2551	parse_events_error__init(&err);
2552	ret = __parse_events(evlist, e->name, /*pmu_filter=*/NULL, &err, /*fake_pmu=*/false,
2553			     /*warn_if_reordered=*/true, /*fake_tp=*/true);
2554	if (ret) {
2555		pr_debug("failed to parse event '%s', err %d\n", e->name, ret);
2556		parse_events_error__print(&err, e->name);
2557		ret = TEST_FAIL;
2558		if (parse_events_error__contains(&err, "can't access trace events"))
2559			ret = TEST_SKIP;
2560	} else {
2561		ret = e->check(evlist);
2562	}
2563	parse_events_error__exit(&err);
2564	evlist__delete(evlist);
2565
2566	return ret;
2567}
2568
2569static int test_event_fake_pmu(const char *str)
2570{
2571	struct parse_events_error err;
2572	struct evlist *evlist;
2573	int ret;
2574
2575	evlist = evlist__new();
2576	if (!evlist)
2577		return -ENOMEM;
2578
2579	parse_events_error__init(&err);
2580	ret = __parse_events(evlist, str, /*pmu_filter=*/NULL, &err,
2581			     /*fake_pmu=*/true, /*warn_if_reordered=*/true,
2582			     /*fake_tp=*/true);
2583	if (ret) {
2584		pr_debug("failed to parse event '%s', err %d\n",
2585			 str, ret);
2586		parse_events_error__print(&err, str);
2587	}
2588
2589	parse_events_error__exit(&err);
2590	evlist__delete(evlist);
2591
2592	return ret;
2593}
2594
2595static int combine_test_results(int existing, int latest)
2596{
2597	if (existing == TEST_FAIL)
2598		return TEST_FAIL;
2599	if (existing == TEST_SKIP)
2600		return latest == TEST_OK ? TEST_SKIP : latest;
2601	return latest;
2602}
2603
2604static int test_events(const struct evlist_test *events, int cnt)
2605{
2606	int ret = TEST_OK;
2607	struct perf_pmu *core_pmu = perf_pmus__find_core_pmu();
2608
2609	for (int i = 0; i < cnt; i++) {
2610		struct evlist_test e = events[i];
2611		int test_ret;
2612		const char *pos = e.name;
2613		char buf[1024], *buf_pos = buf, *end;
2614
2615		while ((end = strstr(pos, "default_core"))) {
2616			size_t len = end - pos;
2617
2618			strncpy(buf_pos, pos, len);
2619			pos = end + 12;
2620			buf_pos += len;
2621			strcpy(buf_pos, core_pmu->name);
2622			buf_pos += strlen(core_pmu->name);
2623		}
2624		strcpy(buf_pos, pos);
2625
2626		e.name = buf;
2627		pr_debug("running test %d '%s'\n", i, e.name);
2628		test_ret = test_event(&e);
2629		if (test_ret != TEST_OK) {
2630			pr_debug("Event test failure: test %d '%s'", i, e.name);
2631			ret = combine_test_results(ret, test_ret);
2632		}
2633	}
2634
2635	return ret;
2636}
2637
2638static int test__events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2639{
2640	return test_events(test__events, ARRAY_SIZE(test__events));
2641}
2642
2643static int test_term(const struct terms_test *t)
2644{
2645	struct parse_events_terms terms;
2646	int ret;
2647
2648
2649	parse_events_terms__init(&terms);
2650	ret = parse_events_terms(&terms, t->str);
2651	if (ret) {
2652		pr_debug("failed to parse terms '%s', err %d\n",
2653			 t->str , ret);
2654		return ret;
2655	}
2656
2657	ret = t->check(&terms);
2658	parse_events_terms__exit(&terms);
2659
2660	return ret;
2661}
2662
2663static int test_terms(const struct terms_test *terms, int cnt)
2664{
2665	int ret = 0;
2666
2667	for (int i = 0; i < cnt; i++) {
2668		const struct terms_test *t = &terms[i];
2669
2670		pr_debug("running test %d '%s'\n", i, t->str);
2671		ret = test_term(t);
2672		if (ret)
2673			break;
2674	}
2675
2676	return ret;
2677}
2678
2679static int test__terms2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2680{
2681	return test_terms(test__terms, ARRAY_SIZE(test__terms));
2682}
2683
2684static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2685{
2686	struct perf_pmu *pmu = NULL;
2687	int ret = TEST_OK;
2688
2689	while ((pmu = perf_pmus__scan(pmu)) != NULL) {
2690		struct stat st;
2691		char path[PATH_MAX];
2692		char pmu_event[PATH_MAX];
2693		char *buf = NULL;
2694		FILE *file;
2695		struct dirent *ent;
2696		size_t len = 0;
2697		DIR *dir;
2698		int err;
2699		int n;
2700
2701		snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/events/",
2702			sysfs__mountpoint(), pmu->name);
2703
2704		err = stat(path, &st);
2705		if (err) {
2706			pr_debug("skipping PMU %s events tests: %s\n", pmu->name, path);
2707			continue;
2708		}
2709
2710		dir = opendir(path);
2711		if (!dir) {
2712			pr_debug("can't open pmu event dir: %s\n", path);
2713			ret = combine_test_results(ret, TEST_SKIP);
2714			continue;
2715		}
2716
2717		while ((ent = readdir(dir))) {
2718			struct evlist_test e = { .name = NULL, };
2719			char name[2 * NAME_MAX + 1 + 12 + 3];
2720			int test_ret;
2721			bool is_event_parameterized = 0;
2722
2723			/* Names containing . are special and cannot be used directly */
2724			if (strchr(ent->d_name, '.'))
2725				continue;
2726
2727			/* exclude parameterized ones (name contains '?') */
2728			n = snprintf(pmu_event, sizeof(pmu_event), "%s%s", path, ent->d_name);
2729			if (n >= PATH_MAX) {
2730				pr_err("pmu event name crossed PATH_MAX(%d) size\n", PATH_MAX);
2731				continue;
2732			}
2733
2734			file = fopen(pmu_event, "r");
2735			if (!file) {
2736				pr_debug("can't open pmu event file for '%s'\n", ent->d_name);
2737				ret = combine_test_results(ret, TEST_FAIL);
2738				continue;
2739			}
2740
2741			if (getline(&buf, &len, file) < 0) {
2742				pr_debug(" pmu event: %s is a null event\n", ent->d_name);
2743				ret = combine_test_results(ret, TEST_FAIL);
2744				fclose(file);
2745				continue;
2746			}
2747
2748			if (strchr(buf, '?'))
2749				is_event_parameterized = 1;
2750
2751			free(buf);
2752			buf = NULL;
2753			fclose(file);
2754
2755			if (is_event_parameterized == 1) {
2756				pr_debug("skipping parameterized PMU event: %s which contains ?\n", pmu_event);
2757				continue;
2758			}
2759
2760			snprintf(name, sizeof(name), "%s/event=%s/u", pmu->name, ent->d_name);
2761
2762			e.name  = name;
2763			e.check = test__checkevent_pmu_events;
2764
2765			test_ret = test_event(&e);
2766			if (test_ret != TEST_OK) {
2767				pr_debug("Test PMU event failed for '%s'", name);
2768				ret = combine_test_results(ret, test_ret);
2769			}
2770
2771			if (!is_pmu_core(pmu->name))
2772				continue;
2773
2774			/*
2775			 * Names containing '-' are recognized as prefixes and suffixes
2776			 * due to '-' being a legacy PMU separator. This fails when the
2777			 * prefix or suffix collides with an existing legacy token. For
2778			 * example, branch-brs has a prefix (branch) that collides with
2779			 * a PE_NAME_CACHE_TYPE token causing a parse error as a suffix
2780			 * isn't expected after this. As event names in the config
2781			 * slashes are allowed a '-' in the name we check this works
2782			 * above.
2783			 */
2784			if (strchr(ent->d_name, '-'))
2785				continue;
2786
2787			snprintf(name, sizeof(name), "%s:u,%s/event=%s/u",
2788				 ent->d_name, pmu->name, ent->d_name);
2789			e.name  = name;
2790			e.check = test__checkevent_pmu_events_mix;
2791			test_ret = test_event(&e);
2792			if (test_ret != TEST_OK) {
2793				pr_debug("Test PMU event failed for '%s'", name);
2794				ret = combine_test_results(ret, test_ret);
2795			}
2796		}
2797
2798		closedir(dir);
2799	}
2800	return ret;
2801}
2802
2803static int test__pmu_events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2804{
2805	return test_events(test__events_pmu, ARRAY_SIZE(test__events_pmu));
2806}
2807
2808static bool test_alias(char **event, char **alias)
2809{
2810	char path[PATH_MAX];
2811	DIR *dir;
2812	struct dirent *dent;
2813	const char *sysfs = sysfs__mountpoint();
2814	char buf[128];
2815	FILE *file;
2816
2817	if (!sysfs)
2818		return false;
2819
2820	snprintf(path, PATH_MAX, "%s/bus/event_source/devices/", sysfs);
2821	dir = opendir(path);
2822	if (!dir)
2823		return false;
2824
2825	while ((dent = readdir(dir))) {
2826		if (!strcmp(dent->d_name, ".") ||
2827		    !strcmp(dent->d_name, ".."))
2828			continue;
2829
2830		snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/alias",
2831			 sysfs, dent->d_name);
2832
2833		if (!file_available(path))
2834			continue;
2835
2836		file = fopen(path, "r");
2837		if (!file)
2838			continue;
2839
2840		if (!fgets(buf, sizeof(buf), file)) {
2841			fclose(file);
2842			continue;
2843		}
2844
2845		/* Remove the last '\n' */
2846		buf[strlen(buf) - 1] = 0;
2847
2848		fclose(file);
2849		*event = strdup(dent->d_name);
2850		*alias = strdup(buf);
2851		closedir(dir);
2852
2853		if (*event == NULL || *alias == NULL) {
2854			free(*event);
2855			free(*alias);
2856			return false;
2857		}
2858
2859		return true;
2860	}
2861
2862	closedir(dir);
2863	return false;
2864}
2865
2866static int test__checkevent_pmu_events_alias(struct evlist *evlist)
2867{
2868	struct evsel *evsel1 = evlist__first(evlist);
2869	struct evsel *evsel2 = evlist__last(evlist);
2870
2871	TEST_ASSERT_EVSEL("wrong type", evsel1->core.attr.type == evsel2->core.attr.type, evsel1);
2872	TEST_ASSERT_EVSEL("wrong config", evsel1->core.attr.config == evsel2->core.attr.config,
2873			  evsel1);
2874	return TEST_OK;
2875}
2876
2877static int test__pmu_events_alias(char *event, char *alias)
2878{
2879	struct evlist_test e = { .name = NULL, };
2880	char name[2 * NAME_MAX + 20];
2881
2882	snprintf(name, sizeof(name), "%s/event=1/,%s/event=1/",
2883		 event, alias);
2884
2885	e.name  = name;
2886	e.check = test__checkevent_pmu_events_alias;
2887	return test_event(&e);
2888}
2889
2890static int test__alias(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2891{
2892	char *event, *alias;
2893	int ret;
2894
2895	if (!test_alias(&event, &alias))
2896		return TEST_SKIP;
2897
2898	ret = test__pmu_events_alias(event, alias);
2899
2900	free(event);
2901	free(alias);
2902	return ret;
2903}
2904
2905static int test__pmu_events_alias2(struct test_suite *test __maybe_unused,
2906				   int subtest __maybe_unused)
2907{
2908	static const char events[][30] = {
2909			"event-hyphen",
2910			"event-two-hyph",
2911	};
2912	int ret = TEST_OK;
2913
2914	for (unsigned int i = 0; i < ARRAY_SIZE(events); i++) {
2915		int test_ret = test_event_fake_pmu(&events[i][0]);
2916
2917		if (test_ret != TEST_OK) {
2918			pr_debug("check_parse_fake %s failed\n", &events[i][0]);
2919			ret = combine_test_results(ret, test_ret);
2920		}
2921	}
2922
2923	return ret;
2924}
2925
2926static struct test_case tests__parse_events[] = {
2927	TEST_CASE_REASON("Test event parsing",
2928			 events2,
2929			 "permissions"),
2930	TEST_CASE_REASON("Parsing of all PMU events from sysfs",
2931			 pmu_events,
2932			 "permissions"),
2933	TEST_CASE_REASON("Parsing of given PMU events from sysfs",
2934			 pmu_events2,
2935			 "permissions"),
2936	TEST_CASE_REASON("Parsing of aliased events from sysfs", alias,
2937			 "no aliases in sysfs"),
2938	TEST_CASE("Parsing of aliased events", pmu_events_alias2),
2939	TEST_CASE("Parsing of terms (event modifiers)", terms2),
2940	{	.name = NULL, }
2941};
2942
2943struct test_suite suite__parse_events = {
2944	.desc = "Parse event definition strings",
2945	.test_cases = tests__parse_events,
2946};