tools/perf/tests/parse-events.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "parse-events.h"
   3 #include "evsel.h"
   4 #include "evlist.h"
   5 #include <api/fs/fs.h>
   6 #include "tests.h"
   7 #include "debug.h"
   8 #include "pmu.h"
   9 #include "pmu-hybrid.h"
  10 #include <dirent.h>
  11 #include <errno.h>
  12 #include "fncache.h"
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <unistd.h>
  16 #include <linux/kernel.h>
  17 #include <linux/hw_breakpoint.h>
  18 #include <api/fs/tracing_path.h>
  19
  20 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
  21                              PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
  22
  23 #if defined(__s390x__)
  24 /* Return true if kvm module is available and loaded. Test this
  25  * and return success when trace point kvm_s390_create_vm
  26  * exists. Otherwise this test always fails.
  27  */
  28 static bool kvm_s390_create_vm_valid(void)
  29 {
  30         char *eventfile;
  31         bool rc = false;
  32
  33         eventfile = get_events_file("kvm-s390");
  34
  35         if (eventfile) {
  36                 DIR *mydir = opendir(eventfile);
  37
  38                 if (mydir) {
  39                         rc = true;
  40                         closedir(mydir);
  41                 }
  42                 put_events_file(eventfile);
  43         }
  44
  45         return rc;
  46 }
  47 #endif
  48
  49 static int test__checkevent_tracepoint(struct evlist *evlist)
  50 {
  51         struct evsel *evsel = evlist__first(evlist);
  52
  53         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  54         TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->core.nr_groups);
  55         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
  56         TEST_ASSERT_VAL("wrong sample_type",
  57                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
  58         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
  59         return TEST_OK;
  60 }
  61
  62 static int test__checkevent_tracepoint_multi(struct evlist *evlist)
  63 {
  64         struct evsel *evsel;
  65
  66         TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
  67         TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->core.nr_groups);
  68
  69         evlist__for_each_entry(evlist, evsel) {
  70                 TEST_ASSERT_VAL("wrong type",
  71                         PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
  72                 TEST_ASSERT_VAL("wrong sample_type",
  73                         PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
  74                 TEST_ASSERT_VAL("wrong sample_period",
  75                         1 == evsel->core.attr.sample_period);
  76         }
  77         return TEST_OK;
  78 }
  79
  80 static int test__checkevent_raw(struct evlist *evlist)
  81 {
  82         struct evsel *evsel = evlist__first(evlist);
  83
  84         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  85         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
  86         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
  87         return TEST_OK;
  88 }
  89
  90 static int test__checkevent_numeric(struct evlist *evlist)
  91 {
  92         struct evsel *evsel = evlist__first(evlist);
  93
  94         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
  95         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
  96         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
  97         return TEST_OK;
  98 }
  99
 100 static int test__checkevent_symbolic_name(struct evlist *evlist)
 101 {
 102         struct evsel *evsel = evlist__first(evlist);
 103
 104         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 105         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 106         TEST_ASSERT_VAL("wrong config",
 107                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 108         return TEST_OK;
 109 }
 110
 111 static int test__checkevent_symbolic_name_config(struct evlist *evlist)
 112 {
 113         struct evsel *evsel = evlist__first(evlist);
 114
 115         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 116         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 117         TEST_ASSERT_VAL("wrong config",
 118                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 119         /*
 120          * The period value gets configured within evlist__config,
 121          * while this test executes only parse events method.
 122          */
 123         TEST_ASSERT_VAL("wrong period",
 124                         0 == evsel->core.attr.sample_period);
 125         TEST_ASSERT_VAL("wrong config1",
 126                         0 == evsel->core.attr.config1);
 127         TEST_ASSERT_VAL("wrong config2",
 128                         1 == evsel->core.attr.config2);
 129         return TEST_OK;
 130 }
 131
 132 static int test__checkevent_symbolic_alias(struct evlist *evlist)
 133 {
 134         struct evsel *evsel = evlist__first(evlist);
 135
 136         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 137         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
 138         TEST_ASSERT_VAL("wrong config",
 139                         PERF_COUNT_SW_PAGE_FAULTS == evsel->core.attr.config);
 140         return TEST_OK;
 141 }
 142
 143 static int test__checkevent_genhw(struct evlist *evlist)
 144 {
 145         struct evsel *evsel = evlist__first(evlist);
 146
 147         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 148         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);
 149         TEST_ASSERT_VAL("wrong config", (1 << 16) == evsel->core.attr.config);
 150         return TEST_OK;
 151 }
 152
 153 static int test__checkevent_breakpoint(struct evlist *evlist)
 154 {
 155         struct evsel *evsel = evlist__first(evlist);
 156
 157         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 158         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 159         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 160         TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
 161                                          evsel->core.attr.bp_type);
 162         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_4 ==
 163                                         evsel->core.attr.bp_len);
 164         return TEST_OK;
 165 }
 166
 167 static int test__checkevent_breakpoint_x(struct evlist *evlist)
 168 {
 169         struct evsel *evsel = evlist__first(evlist);
 170
 171         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 172         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 173         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 174         TEST_ASSERT_VAL("wrong bp_type",
 175                         HW_BREAKPOINT_X == evsel->core.attr.bp_type);
 176         TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->core.attr.bp_len);
 177         return TEST_OK;
 178 }
 179
 180 static int test__checkevent_breakpoint_r(struct evlist *evlist)
 181 {
 182         struct evsel *evsel = evlist__first(evlist);
 183
 184         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 185         TEST_ASSERT_VAL("wrong type",
 186                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 187         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 188         TEST_ASSERT_VAL("wrong bp_type",
 189                         HW_BREAKPOINT_R == evsel->core.attr.bp_type);
 190         TEST_ASSERT_VAL("wrong bp_len",
 191                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 192         return TEST_OK;
 193 }
 194
 195 static int test__checkevent_breakpoint_w(struct evlist *evlist)
 196 {
 197         struct evsel *evsel = evlist__first(evlist);
 198
 199         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 200         TEST_ASSERT_VAL("wrong type",
 201                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 202         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 203         TEST_ASSERT_VAL("wrong bp_type",
 204                         HW_BREAKPOINT_W == evsel->core.attr.bp_type);
 205         TEST_ASSERT_VAL("wrong bp_len",
 206                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 207         return TEST_OK;
 208 }
 209
 210 static int test__checkevent_breakpoint_rw(struct evlist *evlist)
 211 {
 212         struct evsel *evsel = evlist__first(evlist);
 213
 214         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 215         TEST_ASSERT_VAL("wrong type",
 216                         PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
 217         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
 218         TEST_ASSERT_VAL("wrong bp_type",
 219                 (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->core.attr.bp_type);
 220         TEST_ASSERT_VAL("wrong bp_len",
 221                         HW_BREAKPOINT_LEN_4 == evsel->core.attr.bp_len);
 222         return TEST_OK;
 223 }
 224
 225 static int test__checkevent_tracepoint_modifier(struct evlist *evlist)
 226 {
 227         struct evsel *evsel = evlist__first(evlist);
 228
 229         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 230         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 231         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 232         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 233
 234         return test__checkevent_tracepoint(evlist);
 235 }
 236
 237 static int
 238 test__checkevent_tracepoint_multi_modifier(struct evlist *evlist)
 239 {
 240         struct evsel *evsel;
 241
 242         TEST_ASSERT_VAL("wrong number of entries", evlist->core.nr_entries > 1);
 243
 244         evlist__for_each_entry(evlist, evsel) {
 245                 TEST_ASSERT_VAL("wrong exclude_user",
 246                                 !evsel->core.attr.exclude_user);
 247                 TEST_ASSERT_VAL("wrong exclude_kernel",
 248                                 evsel->core.attr.exclude_kernel);
 249                 TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 250                 TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 251         }
 252
 253         return test__checkevent_tracepoint_multi(evlist);
 254 }
 255
 256 static int test__checkevent_raw_modifier(struct evlist *evlist)
 257 {
 258         struct evsel *evsel = evlist__first(evlist);
 259
 260         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 261         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 262         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 263         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 264
 265         return test__checkevent_raw(evlist);
 266 }
 267
 268 static int test__checkevent_numeric_modifier(struct evlist *evlist)
 269 {
 270         struct evsel *evsel = evlist__first(evlist);
 271
 272         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 273         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 274         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 275         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 276
 277         return test__checkevent_numeric(evlist);
 278 }
 279
 280 static int test__checkevent_symbolic_name_modifier(struct evlist *evlist)
 281 {
 282         struct evsel *evsel = evlist__first(evlist);
 283
 284         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 285         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 286         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 287         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 288
 289         return test__checkevent_symbolic_name(evlist);
 290 }
 291
 292 static int test__checkevent_exclude_host_modifier(struct evlist *evlist)
 293 {
 294         struct evsel *evsel = evlist__first(evlist);
 295
 296         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 297         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 298
 299         return test__checkevent_symbolic_name(evlist);
 300 }
 301
 302 static int test__checkevent_exclude_guest_modifier(struct evlist *evlist)
 303 {
 304         struct evsel *evsel = evlist__first(evlist);
 305
 306         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 307         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 308
 309         return test__checkevent_symbolic_name(evlist);
 310 }
 311
 312 static int test__checkevent_symbolic_alias_modifier(struct evlist *evlist)
 313 {
 314         struct evsel *evsel = evlist__first(evlist);
 315
 316         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 317         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 318         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 319         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 320
 321         return test__checkevent_symbolic_alias(evlist);
 322 }
 323
 324 static int test__checkevent_genhw_modifier(struct evlist *evlist)
 325 {
 326         struct evsel *evsel = evlist__first(evlist);
 327
 328         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 329         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 330         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 331         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 332
 333         return test__checkevent_genhw(evlist);
 334 }
 335
 336 static int test__checkevent_exclude_idle_modifier(struct evlist *evlist)
 337 {
 338         struct evsel *evsel = evlist__first(evlist);
 339
 340         TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
 341         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 342         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 343         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 344         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 345         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 346         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 347
 348         return test__checkevent_symbolic_name(evlist);
 349 }
 350
 351 static int test__checkevent_exclude_idle_modifier_1(struct evlist *evlist)
 352 {
 353         struct evsel *evsel = evlist__first(evlist);
 354
 355         TEST_ASSERT_VAL("wrong exclude idle", evsel->core.attr.exclude_idle);
 356         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 357         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 358         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 359         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 360         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 361         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 362
 363         return test__checkevent_symbolic_name(evlist);
 364 }
 365
 366 static int test__checkevent_breakpoint_modifier(struct evlist *evlist)
 367 {
 368         struct evsel *evsel = evlist__first(evlist);
 369
 370
 371         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 372         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 373         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 374         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 375         TEST_ASSERT_VAL("wrong name",
 376                         !strcmp(evsel__name(evsel), "mem:0:u"));
 377
 378         return test__checkevent_breakpoint(evlist);
 379 }
 380
 381 static int test__checkevent_breakpoint_x_modifier(struct evlist *evlist)
 382 {
 383         struct evsel *evsel = evlist__first(evlist);
 384
 385         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 386         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 387         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 388         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 389         TEST_ASSERT_VAL("wrong name",
 390                         !strcmp(evsel__name(evsel), "mem:0:x:k"));
 391
 392         return test__checkevent_breakpoint_x(evlist);
 393 }
 394
 395 static int test__checkevent_breakpoint_r_modifier(struct evlist *evlist)
 396 {
 397         struct evsel *evsel = evlist__first(evlist);
 398
 399         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 400         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 401         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 402         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 403         TEST_ASSERT_VAL("wrong name",
 404                         !strcmp(evsel__name(evsel), "mem:0:r:hp"));
 405
 406         return test__checkevent_breakpoint_r(evlist);
 407 }
 408
 409 static int test__checkevent_breakpoint_w_modifier(struct evlist *evlist)
 410 {
 411         struct evsel *evsel = evlist__first(evlist);
 412
 413         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 414         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 415         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 416         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 417         TEST_ASSERT_VAL("wrong name",
 418                         !strcmp(evsel__name(evsel), "mem:0:w:up"));
 419
 420         return test__checkevent_breakpoint_w(evlist);
 421 }
 422
 423 static int test__checkevent_breakpoint_rw_modifier(struct evlist *evlist)
 424 {
 425         struct evsel *evsel = evlist__first(evlist);
 426
 427         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 428         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 429         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 430         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 431         TEST_ASSERT_VAL("wrong name",
 432                         !strcmp(evsel__name(evsel), "mem:0:rw:kp"));
 433
 434         return test__checkevent_breakpoint_rw(evlist);
 435 }
 436
 437 static int test__checkevent_pmu(struct evlist *evlist)
 438 {
 439
 440         struct evsel *evsel = evlist__first(evlist);
 441
 442         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 443         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 444         TEST_ASSERT_VAL("wrong config",    10 == evsel->core.attr.config);
 445         TEST_ASSERT_VAL("wrong config1",    1 == evsel->core.attr.config1);
 446         TEST_ASSERT_VAL("wrong config2",    3 == evsel->core.attr.config2);
 447         /*
 448          * The period value gets configured within evlist__config,
 449          * while this test executes only parse events method.
 450          */
 451         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 452
 453         return TEST_OK;
 454 }
 455
 456 static int test__checkevent_list(struct evlist *evlist)
 457 {
 458         struct evsel *evsel = evlist__first(evlist);
 459
 460         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 461
 462         /* r1 */
 463         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 464         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
 465         TEST_ASSERT_VAL("wrong config1", 0 == evsel->core.attr.config1);
 466         TEST_ASSERT_VAL("wrong config2", 0 == evsel->core.attr.config2);
 467         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 468         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 469         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 470         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 471
 472         /* syscalls:sys_enter_openat:k */
 473         evsel = evsel__next(evsel);
 474         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
 475         TEST_ASSERT_VAL("wrong sample_type",
 476                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
 477         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
 478         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 479         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 480         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 481         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 482
 483         /* 1:1:hp */
 484         evsel = evsel__next(evsel);
 485         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
 486         TEST_ASSERT_VAL("wrong config", 1 == evsel->core.attr.config);
 487         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 488         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 489         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 490         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
 491
 492         return TEST_OK;
 493 }
 494
 495 static int test__checkevent_pmu_name(struct evlist *evlist)
 496 {
 497         struct evsel *evsel = evlist__first(evlist);
 498
 499         /* cpu/config=1,name=krava/u */
 500         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 501         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 502         TEST_ASSERT_VAL("wrong config",  1 == evsel->core.attr.config);
 503         TEST_ASSERT_VAL("wrong name", !strcmp(evsel__name(evsel), "krava"));
 504
 505         /* cpu/config=2/u" */
 506         evsel = evsel__next(evsel);
 507         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 508         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 509         TEST_ASSERT_VAL("wrong config",  2 == evsel->core.attr.config);
 510         TEST_ASSERT_VAL("wrong name",
 511                         !strcmp(evsel__name(evsel), "cpu/config=2/u"));
 512
 513         return TEST_OK;
 514 }
 515
 516 static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist)
 517 {
 518         struct evsel *evsel = evlist__first(evlist);
 519
 520         /* cpu/config=1,call-graph=fp,time,period=100000/ */
 521         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 522         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 523         TEST_ASSERT_VAL("wrong config",  1 == evsel->core.attr.config);
 524         /*
 525          * The period, time and callgraph value gets configured within evlist__config,
 526          * while this test executes only parse events method.
 527          */
 528         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 529         TEST_ASSERT_VAL("wrong callgraph",  !evsel__has_callchain(evsel));
 530         TEST_ASSERT_VAL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
 531
 532         /* cpu/config=2,call-graph=no,time=0,period=2000/ */
 533         evsel = evsel__next(evsel);
 534         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 535         TEST_ASSERT_VAL("wrong config",  2 == evsel->core.attr.config);
 536         /*
 537          * The period, time and callgraph value gets configured within evlist__config,
 538          * while this test executes only parse events method.
 539          */
 540         TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);
 541         TEST_ASSERT_VAL("wrong callgraph",  !evsel__has_callchain(evsel));
 542         TEST_ASSERT_VAL("wrong time",  !(PERF_SAMPLE_TIME & evsel->core.attr.sample_type));
 543
 544         return TEST_OK;
 545 }
 546
 547 static int test__checkevent_pmu_events(struct evlist *evlist)
 548 {
 549         struct evsel *evsel = evlist__first(evlist);
 550
 551         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
 552         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 553         TEST_ASSERT_VAL("wrong exclude_user",
 554                         !evsel->core.attr.exclude_user);
 555         TEST_ASSERT_VAL("wrong exclude_kernel",
 556                         evsel->core.attr.exclude_kernel);
 557         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 558         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 559         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 560         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
 561
 562         return TEST_OK;
 563 }
 564
 565
 566 static int test__checkevent_pmu_events_mix(struct evlist *evlist)
 567 {
 568         struct evsel *evsel = evlist__first(evlist);
 569
 570         /* pmu-event:u */
 571         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 572         TEST_ASSERT_VAL("wrong exclude_user",
 573                         !evsel->core.attr.exclude_user);
 574         TEST_ASSERT_VAL("wrong exclude_kernel",
 575                         evsel->core.attr.exclude_kernel);
 576         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 577         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 578         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 579         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
 580
 581         /* cpu/pmu-event/u*/
 582         evsel = evsel__next(evsel);
 583         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 584         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
 585         TEST_ASSERT_VAL("wrong exclude_user",
 586                         !evsel->core.attr.exclude_user);
 587         TEST_ASSERT_VAL("wrong exclude_kernel",
 588                         evsel->core.attr.exclude_kernel);
 589         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 590         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 591         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
 592         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.pinned);
 593
 594         return TEST_OK;
 595 }
 596
 597 static int test__checkterms_simple(struct list_head *terms)
 598 {
 599         struct parse_events_term *term;
 600
 601         /* config=10 */
 602         term = list_entry(terms->next, struct parse_events_term, list);
 603         TEST_ASSERT_VAL("wrong type term",
 604                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
 605         TEST_ASSERT_VAL("wrong type val",
 606                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 607         TEST_ASSERT_VAL("wrong val", term->val.num == 10);
 608         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config"));
 609
 610         /* config1 */
 611         term = list_entry(term->list.next, struct parse_events_term, list);
 612         TEST_ASSERT_VAL("wrong type term",
 613                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
 614         TEST_ASSERT_VAL("wrong type val",
 615                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 616         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 617         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config1"));
 618
 619         /* config2=3 */
 620         term = list_entry(term->list.next, struct parse_events_term, list);
 621         TEST_ASSERT_VAL("wrong type term",
 622                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
 623         TEST_ASSERT_VAL("wrong type val",
 624                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 625         TEST_ASSERT_VAL("wrong val", term->val.num == 3);
 626         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config2"));
 627
 628         /* umask=1*/
 629         term = list_entry(term->list.next, struct parse_events_term, list);
 630         TEST_ASSERT_VAL("wrong type term",
 631                         term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
 632         TEST_ASSERT_VAL("wrong type val",
 633                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 634         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 635         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask"));
 636
 637         /*
 638          * read
 639          *
 640          * The perf_pmu__test_parse_init injects 'read' term into
 641          * perf_pmu_events_list, so 'read' is evaluated as read term
 642          * and not as raw event with 'ead' hex value.
 643          */
 644         term = list_entry(term->list.next, struct parse_events_term, list);
 645         TEST_ASSERT_VAL("wrong type term",
 646                         term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
 647         TEST_ASSERT_VAL("wrong type val",
 648                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 649         TEST_ASSERT_VAL("wrong val", term->val.num == 1);
 650         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "read"));
 651
 652         /*
 653          * r0xead
 654          *
 655          * To be still able to pass 'ead' value with 'r' syntax,
 656          * we added support to parse 'r0xHEX' event.
 657          */
 658         term = list_entry(term->list.next, struct parse_events_term, list);
 659         TEST_ASSERT_VAL("wrong type term",
 660                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
 661         TEST_ASSERT_VAL("wrong type val",
 662                         term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
 663         TEST_ASSERT_VAL("wrong val", term->val.num == 0xead);
 664         TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "config"));
 665         return TEST_OK;
 666 }
 667
 668 static int test__group1(struct evlist *evlist)
 669 {
 670         struct evsel *evsel, *leader;
 671
 672         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 673         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 674
 675         /* instructions:k */
 676         evsel = leader = evlist__first(evlist);
 677         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 678         TEST_ASSERT_VAL("wrong config",
 679                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 680         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 681         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 682         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 683         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 684         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 685         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 686         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 687         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 688         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 689         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 690
 691         /* cycles:upp */
 692         evsel = evsel__next(evsel);
 693         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 694         TEST_ASSERT_VAL("wrong config",
 695                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 696         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 697         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 698         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 699         /* use of precise requires exclude_guest */
 700         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 701         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 702         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 703         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 704         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 705         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 706
 707         return TEST_OK;
 708 }
 709
 710 static int test__group2(struct evlist *evlist)
 711 {
 712         struct evsel *evsel, *leader;
 713
 714         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
 715         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 716
 717         /* faults + :ku modifier */
 718         evsel = leader = evlist__first(evlist);
 719         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
 720         TEST_ASSERT_VAL("wrong config",
 721                         PERF_COUNT_SW_PAGE_FAULTS == evsel->core.attr.config);
 722         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 723         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 724         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 725         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 726         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 727         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 728         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 729         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 730         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 731         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 732
 733         /* cache-references + :u modifier */
 734         evsel = evsel__next(evsel);
 735         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 736         TEST_ASSERT_VAL("wrong config",
 737                         PERF_COUNT_HW_CACHE_REFERENCES == evsel->core.attr.config);
 738         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 739         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 740         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 741         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 742         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 743         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 744         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 745         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 746         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 747
 748         /* cycles:k */
 749         evsel = evsel__next(evsel);
 750         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 751         TEST_ASSERT_VAL("wrong config",
 752                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 753         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 754         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 755         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 756         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 757         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 758         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 759         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 760         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 761
 762         return TEST_OK;
 763 }
 764
 765 static int test__group3(struct evlist *evlist __maybe_unused)
 766 {
 767         struct evsel *evsel, *leader;
 768
 769         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 770         TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->core.nr_groups);
 771
 772         /* group1 syscalls:sys_enter_openat:H */
 773         evsel = leader = evlist__first(evlist);
 774         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->core.attr.type);
 775         TEST_ASSERT_VAL("wrong sample_type",
 776                 PERF_TP_SAMPLE_TYPE == evsel->core.attr.sample_type);
 777         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->core.attr.sample_period);
 778         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 779         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 780         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 781         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 782         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 783         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 784         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 785         TEST_ASSERT_VAL("wrong group name",
 786                 !strcmp(leader->group_name, "group1"));
 787         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 788         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 789         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 790
 791         /* group1 cycles:kppp */
 792         evsel = evsel__next(evsel);
 793         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 794         TEST_ASSERT_VAL("wrong config",
 795                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 796         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 797         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 798         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 799         /* use of precise requires exclude_guest */
 800         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 801         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 802         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 3);
 803         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 804         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 805         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 806         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 807
 808         /* group2 cycles + G modifier */
 809         evsel = leader = evsel__next(evsel);
 810         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 811         TEST_ASSERT_VAL("wrong config",
 812                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 813         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 814         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 815         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 816         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 817         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 818         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 819         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 820         TEST_ASSERT_VAL("wrong group name",
 821                 !strcmp(leader->group_name, "group2"));
 822         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 823         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 824         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 825
 826         /* group2 1:3 + G modifier */
 827         evsel = evsel__next(evsel);
 828         TEST_ASSERT_VAL("wrong type", 1 == evsel->core.attr.type);
 829         TEST_ASSERT_VAL("wrong config", 3 == evsel->core.attr.config);
 830         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 831         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 832         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 833         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 834         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 835         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 836         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 837         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 838         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 839
 840         /* instructions:u */
 841         evsel = evsel__next(evsel);
 842         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 843         TEST_ASSERT_VAL("wrong config",
 844                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 845         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 846         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 847         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 848         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 849         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 850         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 851         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 852         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 853
 854         return TEST_OK;
 855 }
 856
 857 static int test__group4(struct evlist *evlist __maybe_unused)
 858 {
 859         struct evsel *evsel, *leader;
 860
 861         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 862         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 863
 864         /* cycles:u + p */
 865         evsel = leader = evlist__first(evlist);
 866         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 867         TEST_ASSERT_VAL("wrong config",
 868                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 869         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 870         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
 871         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 872         /* use of precise requires exclude_guest */
 873         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 874         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 875         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 1);
 876         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 877         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 878         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 879         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 880         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 881
 882         /* instructions:kp + p */
 883         evsel = evsel__next(evsel);
 884         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 885         TEST_ASSERT_VAL("wrong config",
 886                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 887         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
 888         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 889         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
 890         /* use of precise requires exclude_guest */
 891         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 892         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 893         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip == 2);
 894         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 895         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 896         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 897
 898         return TEST_OK;
 899 }
 900
 901 static int test__group5(struct evlist *evlist __maybe_unused)
 902 {
 903         struct evsel *evsel, *leader;
 904
 905         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->core.nr_entries);
 906         TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->core.nr_groups);
 907
 908         /* cycles + G */
 909         evsel = leader = evlist__first(evlist);
 910         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 911         TEST_ASSERT_VAL("wrong config",
 912                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 913         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 914         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 915         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 916         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 917         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 918         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 919         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 920         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 921         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 922         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 923         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 924
 925         /* instructions + G */
 926         evsel = evsel__next(evsel);
 927         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 928         TEST_ASSERT_VAL("wrong config",
 929                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 930         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 931         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 932         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 933         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 934         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 935         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 936         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 937         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 938         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 939
 940         /* cycles:G */
 941         evsel = leader = evsel__next(evsel);
 942         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 943         TEST_ASSERT_VAL("wrong config",
 944                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 945         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 946         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 947         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 948         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 949         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 950         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 951         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
 952         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 953         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
 954         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
 955         TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 956
 957         /* instructions:G */
 958         evsel = evsel__next(evsel);
 959         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 960         TEST_ASSERT_VAL("wrong config",
 961                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
 962         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 963         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 964         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 965         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
 966         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
 967         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 968         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
 969         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
 970
 971         /* cycles */
 972         evsel = evsel__next(evsel);
 973         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 974         TEST_ASSERT_VAL("wrong config",
 975                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 976         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
 977         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
 978         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
 979         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
 980         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
 981         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
 982         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
 983
 984         return TEST_OK;
 985 }
 986
 987 static int test__group_gh1(struct evlist *evlist)
 988 {
 989         struct evsel *evsel, *leader;
 990
 991         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
 992         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
 993
 994         /* cycles + :H group modifier */
 995         evsel = leader = evlist__first(evlist);
 996         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
 997         TEST_ASSERT_VAL("wrong config",
 998                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
 999         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1000         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1001         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1002         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1003         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1004         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1005         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1006         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1007         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1008         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1009
1010         /* cache-misses:G + :H group modifier */
1011         evsel = evsel__next(evsel);
1012         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1013         TEST_ASSERT_VAL("wrong config",
1014                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1015         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1016         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1017         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1018         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1019         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1020         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1021         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1022         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1023
1024         return TEST_OK;
1025 }
1026
1027 static int test__group_gh2(struct evlist *evlist)
1028 {
1029         struct evsel *evsel, *leader;
1030
1031         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1032         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1033
1034         /* cycles + :G group modifier */
1035         evsel = leader = evlist__first(evlist);
1036         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1037         TEST_ASSERT_VAL("wrong config",
1038                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1039         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1040         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1041         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1042         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1043         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1044         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1045         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1046         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1047         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1048         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1049
1050         /* cache-misses:H + :G group modifier */
1051         evsel = evsel__next(evsel);
1052         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1053         TEST_ASSERT_VAL("wrong config",
1054                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1055         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1056         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1057         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1058         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1059         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1060         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1061         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1062         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1063
1064         return TEST_OK;
1065 }
1066
1067 static int test__group_gh3(struct evlist *evlist)
1068 {
1069         struct evsel *evsel, *leader;
1070
1071         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1072         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1073
1074         /* cycles:G + :u group modifier */
1075         evsel = leader = evlist__first(evlist);
1076         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1077         TEST_ASSERT_VAL("wrong config",
1078                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1079         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1080         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1081         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1082         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1083         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1084         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1085         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1086         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1087         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1088         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1089
1090         /* cache-misses:H + :u group modifier */
1091         evsel = evsel__next(evsel);
1092         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1093         TEST_ASSERT_VAL("wrong config",
1094                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1095         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1096         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1097         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1098         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1099         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1100         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1101         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1102         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1103
1104         return TEST_OK;
1105 }
1106
1107 static int test__group_gh4(struct evlist *evlist)
1108 {
1109         struct evsel *evsel, *leader;
1110
1111         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1112         TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->core.nr_groups);
1113
1114         /* cycles:G + :uG group modifier */
1115         evsel = leader = evlist__first(evlist);
1116         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1117         TEST_ASSERT_VAL("wrong config",
1118                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1119         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1120         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1121         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1122         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1123         TEST_ASSERT_VAL("wrong exclude host", evsel->core.attr.exclude_host);
1124         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1125         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1126         TEST_ASSERT_VAL("wrong leader", evsel__is_group_leader(evsel));
1127         TEST_ASSERT_VAL("wrong core.nr_members", evsel->core.nr_members == 2);
1128         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 0);
1129
1130         /* cache-misses:H + :uG group modifier */
1131         evsel = evsel__next(evsel);
1132         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1133         TEST_ASSERT_VAL("wrong config",
1134                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1135         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1136         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1137         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1138         TEST_ASSERT_VAL("wrong exclude guest", !evsel->core.attr.exclude_guest);
1139         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1140         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1141         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1142         TEST_ASSERT_VAL("wrong group_idx", evsel__group_idx(evsel) == 1);
1143
1144         return TEST_OK;
1145 }
1146
1147 static int test__leader_sample1(struct evlist *evlist)
1148 {
1149         struct evsel *evsel, *leader;
1150
1151         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1152
1153         /* cycles - sampling group leader */
1154         evsel = leader = evlist__first(evlist);
1155         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1156         TEST_ASSERT_VAL("wrong config",
1157                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1158         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1159         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1160         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1161         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1162         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1163         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1164         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1165         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1166         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1167
1168         /* cache-misses - not sampling */
1169         evsel = evsel__next(evsel);
1170         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1171         TEST_ASSERT_VAL("wrong config",
1172                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1173         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1174         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1175         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1176         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1177         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1178         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1179         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1180         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1181
1182         /* branch-misses - not sampling */
1183         evsel = evsel__next(evsel);
1184         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1185         TEST_ASSERT_VAL("wrong config",
1186                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1187         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1188         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1189         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->core.attr.exclude_hv);
1190         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1191         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1192         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1193         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1194         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1195         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1196
1197         return TEST_OK;
1198 }
1199
1200 static int test__leader_sample2(struct evlist *evlist __maybe_unused)
1201 {
1202         struct evsel *evsel, *leader;
1203
1204         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1205
1206         /* instructions - sampling group leader */
1207         evsel = leader = evlist__first(evlist);
1208         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1209         TEST_ASSERT_VAL("wrong config",
1210                         PERF_COUNT_HW_INSTRUCTIONS == evsel->core.attr.config);
1211         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1212         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1213         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1214         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1215         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1216         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1217         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1218         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1219         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1220
1221         /* branch-misses - not sampling */
1222         evsel = evsel__next(evsel);
1223         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1224         TEST_ASSERT_VAL("wrong config",
1225                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1226         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1227         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1228         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1229         TEST_ASSERT_VAL("wrong exclude guest", evsel->core.attr.exclude_guest);
1230         TEST_ASSERT_VAL("wrong exclude host", !evsel->core.attr.exclude_host);
1231         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1232         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1233         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1234         TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
1235
1236         return TEST_OK;
1237 }
1238
1239 static int test__checkevent_pinned_modifier(struct evlist *evlist)
1240 {
1241         struct evsel *evsel = evlist__first(evlist);
1242
1243         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1244         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1245         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1246         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1247         TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1248
1249         return test__checkevent_symbolic_name(evlist);
1250 }
1251
1252 static int test__pinned_group(struct evlist *evlist)
1253 {
1254         struct evsel *evsel, *leader;
1255
1256         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1257
1258         /* cycles - group leader */
1259         evsel = leader = evlist__first(evlist);
1260         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1261         TEST_ASSERT_VAL("wrong config",
1262                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1263         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1264         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1265         TEST_ASSERT_VAL("wrong pinned", evsel->core.attr.pinned);
1266
1267         /* cache-misses - can not be pinned, but will go on with the leader */
1268         evsel = evsel__next(evsel);
1269         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1270         TEST_ASSERT_VAL("wrong config",
1271                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1272         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1273
1274         /* branch-misses - ditto */
1275         evsel = evsel__next(evsel);
1276         TEST_ASSERT_VAL("wrong config",
1277                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1278         TEST_ASSERT_VAL("wrong pinned", !evsel->core.attr.pinned);
1279
1280         return TEST_OK;
1281 }
1282
1283 static int test__checkevent_exclusive_modifier(struct evlist *evlist)
1284 {
1285         struct evsel *evsel = evlist__first(evlist);
1286
1287         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1288         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1289         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1290         TEST_ASSERT_VAL("wrong precise_ip", evsel->core.attr.precise_ip);
1291         TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1292
1293         return test__checkevent_symbolic_name(evlist);
1294 }
1295
1296 static int test__exclusive_group(struct evlist *evlist)
1297 {
1298         struct evsel *evsel, *leader;
1299
1300         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->core.nr_entries);
1301
1302         /* cycles - group leader */
1303         evsel = leader = evlist__first(evlist);
1304         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1305         TEST_ASSERT_VAL("wrong config",
1306                         PERF_COUNT_HW_CPU_CYCLES == evsel->core.attr.config);
1307         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
1308         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1309         TEST_ASSERT_VAL("wrong exclusive", evsel->core.attr.exclusive);
1310
1311         /* cache-misses - can not be pinned, but will go on with the leader */
1312         evsel = evsel__next(evsel);
1313         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->core.attr.type);
1314         TEST_ASSERT_VAL("wrong config",
1315                         PERF_COUNT_HW_CACHE_MISSES == evsel->core.attr.config);
1316         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1317
1318         /* branch-misses - ditto */
1319         evsel = evsel__next(evsel);
1320         TEST_ASSERT_VAL("wrong config",
1321                         PERF_COUNT_HW_BRANCH_MISSES == evsel->core.attr.config);
1322         TEST_ASSERT_VAL("wrong exclusive", !evsel->core.attr.exclusive);
1323
1324         return TEST_OK;
1325 }
1326 static int test__checkevent_breakpoint_len(struct evlist *evlist)
1327 {
1328         struct evsel *evsel = evlist__first(evlist);
1329
1330         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1331         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1332         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1333         TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
1334                                          evsel->core.attr.bp_type);
1335         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 ==
1336                                         evsel->core.attr.bp_len);
1337
1338         return TEST_OK;
1339 }
1340
1341 static int test__checkevent_breakpoint_len_w(struct evlist *evlist)
1342 {
1343         struct evsel *evsel = evlist__first(evlist);
1344
1345         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1346         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->core.attr.type);
1347         TEST_ASSERT_VAL("wrong config", 0 == evsel->core.attr.config);
1348         TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W ==
1349                                          evsel->core.attr.bp_type);
1350         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 ==
1351                                         evsel->core.attr.bp_len);
1352
1353         return TEST_OK;
1354 }
1355
1356 static int
1357 test__checkevent_breakpoint_len_rw_modifier(struct evlist *evlist)
1358 {
1359         struct evsel *evsel = evlist__first(evlist);
1360
1361         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1362         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1363         TEST_ASSERT_VAL("wrong exclude_hv", evsel->core.attr.exclude_hv);
1364         TEST_ASSERT_VAL("wrong precise_ip", !evsel->core.attr.precise_ip);
1365
1366         return test__checkevent_breakpoint_rw(evlist);
1367 }
1368
1369 static int test__checkevent_precise_max_modifier(struct evlist *evlist)
1370 {
1371         struct evsel *evsel = evlist__first(evlist);
1372
1373         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1374         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1375         TEST_ASSERT_VAL("wrong config",
1376                         PERF_COUNT_SW_TASK_CLOCK == evsel->core.attr.config);
1377         return TEST_OK;
1378 }
1379
1380 static int test__checkevent_config_symbol(struct evlist *evlist)
1381 {
1382         struct evsel *evsel = evlist__first(evlist);
1383
1384         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "insn") == 0);
1385         return TEST_OK;
1386 }
1387
1388 static int test__checkevent_config_raw(struct evlist *evlist)
1389 {
1390         struct evsel *evsel = evlist__first(evlist);
1391
1392         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "rawpmu") == 0);
1393         return TEST_OK;
1394 }
1395
1396 static int test__checkevent_config_num(struct evlist *evlist)
1397 {
1398         struct evsel *evsel = evlist__first(evlist);
1399
1400         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "numpmu") == 0);
1401         return TEST_OK;
1402 }
1403
1404 static int test__checkevent_config_cache(struct evlist *evlist)
1405 {
1406         struct evsel *evsel = evlist__first(evlist);
1407
1408         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "cachepmu") == 0);
1409         return TEST_OK;
1410 }
1411
1412 static bool test__intel_pt_valid(void)
1413 {
1414         return !!perf_pmu__find("intel_pt");
1415 }
1416
1417 static int test__intel_pt(struct evlist *evlist)
1418 {
1419         struct evsel *evsel = evlist__first(evlist);
1420
1421         TEST_ASSERT_VAL("wrong name setting", strcmp(evsel->name, "intel_pt//u") == 0);
1422         return TEST_OK;
1423 }
1424
1425 static int test__checkevent_complex_name(struct evlist *evlist)
1426 {
1427         struct evsel *evsel = evlist__first(evlist);
1428
1429         TEST_ASSERT_VAL("wrong complex name parsing", strcmp(evsel->name, "COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks") == 0);
1430         return TEST_OK;
1431 }
1432
1433 static int test__checkevent_raw_pmu(struct evlist *evlist)
1434 {
1435         struct evsel *evsel = evlist__first(evlist);
1436
1437         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1438         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1439         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1440         return TEST_OK;
1441 }
1442
1443 static int test__sym_event_slash(struct evlist *evlist)
1444 {
1445         struct evsel *evsel = evlist__first(evlist);
1446
1447         TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1448         TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1449         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1450         return TEST_OK;
1451 }
1452
1453 static int test__sym_event_dc(struct evlist *evlist)
1454 {
1455         struct evsel *evsel = evlist__first(evlist);
1456
1457         TEST_ASSERT_VAL("wrong type", evsel->core.attr.type == PERF_TYPE_HARDWARE);
1458         TEST_ASSERT_VAL("wrong config", evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES);
1459         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1460         return TEST_OK;
1461 }
1462
1463 static int count_tracepoints(void)
1464 {
1465         struct dirent *events_ent;
1466         DIR *events_dir;
1467         int cnt = 0;
1468
1469         events_dir = tracing_events__opendir();
1470
1471         TEST_ASSERT_VAL("Can't open events dir", events_dir);
1472
1473         while ((events_ent = readdir(events_dir))) {
1474                 char *sys_path;
1475                 struct dirent *sys_ent;
1476                 DIR *sys_dir;
1477
1478                 if (!strcmp(events_ent->d_name, ".")
1479                     || !strcmp(events_ent->d_name, "..")
1480                     || !strcmp(events_ent->d_name, "enable")
1481                     || !strcmp(events_ent->d_name, "header_event")
1482                     || !strcmp(events_ent->d_name, "header_page"))
1483                         continue;
1484
1485                 sys_path = get_events_file(events_ent->d_name);
1486                 TEST_ASSERT_VAL("Can't get sys path", sys_path);
1487
1488                 sys_dir = opendir(sys_path);
1489                 TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
1490
1491                 while ((sys_ent = readdir(sys_dir))) {
1492                         if (!strcmp(sys_ent->d_name, ".")
1493                             || !strcmp(sys_ent->d_name, "..")
1494                             || !strcmp(sys_ent->d_name, "enable")
1495                             || !strcmp(sys_ent->d_name, "filter"))
1496                                 continue;
1497
1498                         cnt++;
1499                 }
1500
1501                 closedir(sys_dir);
1502                 put_events_file(sys_path);
1503         }
1504
1505         closedir(events_dir);
1506         return cnt;
1507 }
1508
1509 static int test__all_tracepoints(struct evlist *evlist)
1510 {
1511         TEST_ASSERT_VAL("wrong events count",
1512                         count_tracepoints() == evlist->core.nr_entries);
1513
1514         return test__checkevent_tracepoint_multi(evlist);
1515 }
1516
1517 static int test__hybrid_hw_event_with_pmu(struct evlist *evlist)
1518 {
1519         struct evsel *evsel = evlist__first(evlist);
1520
1521         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1522         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1523         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1524         return TEST_OK;
1525 }
1526
1527 static int test__hybrid_hw_group_event(struct evlist *evlist)
1528 {
1529         struct evsel *evsel, *leader;
1530
1531         evsel = leader = evlist__first(evlist);
1532         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1533         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1534         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1535         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1536
1537         evsel = evsel__next(evsel);
1538         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1539         TEST_ASSERT_VAL("wrong config", 0xc0 == evsel->core.attr.config);
1540         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1541         return TEST_OK;
1542 }
1543
1544 static int test__hybrid_sw_hw_group_event(struct evlist *evlist)
1545 {
1546         struct evsel *evsel, *leader;
1547
1548         evsel = leader = evlist__first(evlist);
1549         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1550         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1551         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1552
1553         evsel = evsel__next(evsel);
1554         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1555         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1556         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1557         return TEST_OK;
1558 }
1559
1560 static int test__hybrid_hw_sw_group_event(struct evlist *evlist)
1561 {
1562         struct evsel *evsel, *leader;
1563
1564         evsel = leader = evlist__first(evlist);
1565         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1566         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1567         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1568         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1569
1570         evsel = evsel__next(evsel);
1571         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);
1572         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1573         return TEST_OK;
1574 }
1575
1576 static int test__hybrid_group_modifier1(struct evlist *evlist)
1577 {
1578         struct evsel *evsel, *leader;
1579
1580         evsel = leader = evlist__first(evlist);
1581         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1582         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1583         TEST_ASSERT_VAL("wrong config", 0x3c == evsel->core.attr.config);
1584         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1585         TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);
1586         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);
1587
1588         evsel = evsel__next(evsel);
1589         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1590         TEST_ASSERT_VAL("wrong config", 0xc0 == evsel->core.attr.config);
1591         TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));
1592         TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);
1593         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);
1594         return TEST_OK;
1595 }
1596
1597 static int test__hybrid_raw1(struct evlist *evlist)
1598 {
1599         struct evsel *evsel = evlist__first(evlist);
1600
1601         if (!perf_pmu__hybrid_mounted("cpu_atom")) {
1602                 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1603                 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1604                 TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1605                 return TEST_OK;
1606         }
1607
1608         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);
1609         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1610         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1611
1612         /* The type of second event is randome value */
1613         evsel = evsel__next(evsel);
1614         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1615         return TEST_OK;
1616 }
1617
1618 static int test__hybrid_raw2(struct evlist *evlist)
1619 {
1620         struct evsel *evsel = evlist__first(evlist);
1621
1622         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1623         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);
1624         TEST_ASSERT_VAL("wrong config", 0x1a == evsel->core.attr.config);
1625         return TEST_OK;
1626 }
1627
1628 static int test__hybrid_cache_event(struct evlist *evlist)
1629 {
1630         struct evsel *evsel = evlist__first(evlist);
1631
1632         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);
1633         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);
1634         TEST_ASSERT_VAL("wrong config", 0x2 == (evsel->core.attr.config & 0xffffffff));
1635         return TEST_OK;
1636 }
1637
1638 struct evlist_test {
1639         const char *name;
1640         bool (*valid)(void);
1641         int (*check)(struct evlist *evlist);
1642 };
1643
1644 static const struct evlist_test test__events[] = {
1645         {
1646                 .name  = "syscalls:sys_enter_openat",
1647                 .check = test__checkevent_tracepoint,
1648                 /* 0 */
1649         },
1650         {
1651                 .name  = "syscalls:*",
1652                 .check = test__checkevent_tracepoint_multi,
1653                 /* 1 */
1654         },
1655         {
1656                 .name  = "r1a",
1657                 .check = test__checkevent_raw,
1658                 /* 2 */
1659         },
1660         {
1661                 .name  = "1:1",
1662                 .check = test__checkevent_numeric,
1663                 /* 3 */
1664         },
1665         {
1666                 .name  = "instructions",
1667                 .check = test__checkevent_symbolic_name,
1668                 /* 4 */
1669         },
1670         {
1671                 .name  = "cycles/period=100000,config2/",
1672                 .check = test__checkevent_symbolic_name_config,
1673                 /* 5 */
1674         },
1675         {
1676                 .name  = "faults",
1677                 .check = test__checkevent_symbolic_alias,
1678                 /* 6 */
1679         },
1680         {
1681                 .name  = "L1-dcache-load-miss",
1682                 .check = test__checkevent_genhw,
1683                 /* 7 */
1684         },
1685         {
1686                 .name  = "mem:0",
1687                 .check = test__checkevent_breakpoint,
1688                 /* 8 */
1689         },
1690         {
1691                 .name  = "mem:0:x",
1692                 .check = test__checkevent_breakpoint_x,
1693                 /* 9 */
1694         },
1695         {
1696                 .name  = "mem:0:r",
1697                 .check = test__checkevent_breakpoint_r,
1698                 /* 0 */
1699         },
1700         {
1701                 .name  = "mem:0:w",
1702                 .check = test__checkevent_breakpoint_w,
1703                 /* 1 */
1704         },
1705         {
1706                 .name  = "syscalls:sys_enter_openat:k",
1707                 .check = test__checkevent_tracepoint_modifier,
1708                 /* 2 */
1709         },
1710         {
1711                 .name  = "syscalls:*:u",
1712                 .check = test__checkevent_tracepoint_multi_modifier,
1713                 /* 3 */
1714         },
1715         {
1716                 .name  = "r1a:kp",
1717                 .check = test__checkevent_raw_modifier,
1718                 /* 4 */
1719         },
1720         {
1721                 .name  = "1:1:hp",
1722                 .check = test__checkevent_numeric_modifier,
1723                 /* 5 */
1724         },
1725         {
1726                 .name  = "instructions:h",
1727                 .check = test__checkevent_symbolic_name_modifier,
1728                 /* 6 */
1729         },
1730         {
1731                 .name  = "faults:u",
1732                 .check = test__checkevent_symbolic_alias_modifier,
1733                 /* 7 */
1734         },
1735         {
1736                 .name  = "L1-dcache-load-miss:kp",
1737                 .check = test__checkevent_genhw_modifier,
1738                 /* 8 */
1739         },
1740         {
1741                 .name  = "mem:0:u",
1742                 .check = test__checkevent_breakpoint_modifier,
1743                 /* 9 */
1744         },
1745         {
1746                 .name  = "mem:0:x:k",
1747                 .check = test__checkevent_breakpoint_x_modifier,
1748                 /* 0 */
1749         },
1750         {
1751                 .name  = "mem:0:r:hp",
1752                 .check = test__checkevent_breakpoint_r_modifier,
1753                 /* 1 */
1754         },
1755         {
1756                 .name  = "mem:0:w:up",
1757                 .check = test__checkevent_breakpoint_w_modifier,
1758                 /* 2 */
1759         },
1760         {
1761                 .name  = "r1,syscalls:sys_enter_openat:k,1:1:hp",
1762                 .check = test__checkevent_list,
1763                 /* 3 */
1764         },
1765         {
1766                 .name  = "instructions:G",
1767                 .check = test__checkevent_exclude_host_modifier,
1768                 /* 4 */
1769         },
1770         {
1771                 .name  = "instructions:H",
1772                 .check = test__checkevent_exclude_guest_modifier,
1773                 /* 5 */
1774         },
1775         {
1776                 .name  = "mem:0:rw",
1777                 .check = test__checkevent_breakpoint_rw,
1778                 /* 6 */
1779         },
1780         {
1781                 .name  = "mem:0:rw:kp",
1782                 .check = test__checkevent_breakpoint_rw_modifier,
1783                 /* 7 */
1784         },
1785         {
1786                 .name  = "{instructions:k,cycles:upp}",
1787                 .check = test__group1,
1788                 /* 8 */
1789         },
1790         {
1791                 .name  = "{faults:k,cache-references}:u,cycles:k",
1792                 .check = test__group2,
1793                 /* 9 */
1794         },
1795         {
1796                 .name  = "group1{syscalls:sys_enter_openat:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u",
1797                 .check = test__group3,
1798                 /* 0 */
1799         },
1800         {
1801                 .name  = "{cycles:u,instructions:kp}:p",
1802                 .check = test__group4,
1803                 /* 1 */
1804         },
1805         {
1806                 .name  = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
1807                 .check = test__group5,
1808                 /* 2 */
1809         },
1810         {
1811                 .name  = "*:*",
1812                 .check = test__all_tracepoints,
1813                 /* 3 */
1814         },
1815         {
1816                 .name  = "{cycles,cache-misses:G}:H",
1817                 .check = test__group_gh1,
1818                 /* 4 */
1819         },
1820         {
1821                 .name  = "{cycles,cache-misses:H}:G",
1822                 .check = test__group_gh2,
1823                 /* 5 */
1824         },
1825         {
1826                 .name  = "{cycles:G,cache-misses:H}:u",
1827                 .check = test__group_gh3,
1828                 /* 6 */
1829         },
1830         {
1831                 .name  = "{cycles:G,cache-misses:H}:uG",
1832                 .check = test__group_gh4,
1833                 /* 7 */
1834         },
1835         {
1836                 .name  = "{cycles,cache-misses,branch-misses}:S",
1837                 .check = test__leader_sample1,
1838                 /* 8 */
1839         },
1840         {
1841                 .name  = "{instructions,branch-misses}:Su",
1842                 .check = test__leader_sample2,
1843                 /* 9 */
1844         },
1845         {
1846                 .name  = "instructions:uDp",
1847                 .check = test__checkevent_pinned_modifier,
1848                 /* 0 */
1849         },
1850         {
1851                 .name  = "{cycles,cache-misses,branch-misses}:D",
1852                 .check = test__pinned_group,
1853                 /* 1 */
1854         },
1855         {
1856                 .name  = "mem:0/1",
1857                 .check = test__checkevent_breakpoint_len,
1858                 /* 2 */
1859         },
1860         {
1861                 .name  = "mem:0/2:w",
1862                 .check = test__checkevent_breakpoint_len_w,
1863                 /* 3 */
1864         },
1865         {
1866                 .name  = "mem:0/4:rw:u",
1867                 .check = test__checkevent_breakpoint_len_rw_modifier,
1868                 /* 4 */
1869         },
1870 #if defined(__s390x__)
1871         {
1872                 .name  = "kvm-s390:kvm_s390_create_vm",
1873                 .check = test__checkevent_tracepoint,
1874                 .valid = kvm_s390_create_vm_valid,
1875                 /* 0 */
1876         },
1877 #endif
1878         {
1879                 .name  = "instructions:I",
1880                 .check = test__checkevent_exclude_idle_modifier,
1881                 /* 5 */
1882         },
1883         {
1884                 .name  = "instructions:kIG",
1885                 .check = test__checkevent_exclude_idle_modifier_1,
1886                 /* 6 */
1887         },
1888         {
1889                 .name  = "task-clock:P,cycles",
1890                 .check = test__checkevent_precise_max_modifier,
1891                 /* 7 */
1892         },
1893         {
1894                 .name  = "instructions/name=insn/",
1895                 .check = test__checkevent_config_symbol,
1896                 /* 8 */
1897         },
1898         {
1899                 .name  = "r1234/name=rawpmu/",
1900                 .check = test__checkevent_config_raw,
1901                 /* 9 */
1902         },
1903         {
1904                 .name  = "4:0x6530160/name=numpmu/",
1905                 .check = test__checkevent_config_num,
1906                 /* 0 */
1907         },
1908         {
1909                 .name  = "L1-dcache-misses/name=cachepmu/",
1910                 .check = test__checkevent_config_cache,
1911                 /* 1 */
1912         },
1913         {
1914                 .name  = "intel_pt//u",
1915                 .valid = test__intel_pt_valid,
1916                 .check = test__intel_pt,
1917                 /* 2 */
1918         },
1919         {
1920                 .name  = "cycles/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks'/Duk",
1921                 .check = test__checkevent_complex_name,
1922                 /* 3 */
1923         },
1924         {
1925                 .name  = "cycles//u",
1926                 .check = test__sym_event_slash,
1927                 /* 4 */
1928         },
1929         {
1930                 .name  = "cycles:k",
1931                 .check = test__sym_event_dc,
1932                 /* 5 */
1933         },
1934         {
1935                 .name  = "instructions:uep",
1936                 .check = test__checkevent_exclusive_modifier,
1937                 /* 6 */
1938         },
1939         {
1940                 .name  = "{cycles,cache-misses,branch-misses}:e",
1941                 .check = test__exclusive_group,
1942                 /* 7 */
1943         },
1944 };
1945
1946 static const struct evlist_test test__events_pmu[] = {
1947         {
1948                 .name  = "cpu/config=10,config1,config2=3,period=1000/u",
1949                 .check = test__checkevent_pmu,
1950                 /* 0 */
1951         },
1952         {
1953                 .name  = "cpu/config=1,name=krava/u,cpu/config=2/u",
1954                 .check = test__checkevent_pmu_name,
1955                 /* 1 */
1956         },
1957         {
1958                 .name  = "cpu/config=1,call-graph=fp,time,period=100000/,cpu/config=2,call-graph=no,time=0,period=2000/",
1959                 .check = test__checkevent_pmu_partial_time_callgraph,
1960                 /* 2 */
1961         },
1962         {
1963                 .name  = "cpu/name='COMPLEX_CYCLES_NAME:orig=cycles,desc=chip-clock-ticks',period=0x1,event=0x2/ukp",
1964                 .check = test__checkevent_complex_name,
1965                 /* 3 */
1966         },
1967         {
1968                 .name  = "software/r1a/",
1969                 .check = test__checkevent_raw_pmu,
1970                 /* 4 */
1971         },
1972         {
1973                 .name  = "software/r0x1a/",
1974                 .check = test__checkevent_raw_pmu,
1975                 /* 5 */
1976         },
1977 };
1978
1979 struct terms_test {
1980         const char *str;
1981         int (*check)(struct list_head *terms);
1982 };
1983
1984 static const struct terms_test test__terms[] = {
1985         [0] = {
1986                 .str   = "config=10,config1,config2=3,umask=1,read,r0xead",
1987                 .check = test__checkterms_simple,
1988         },
1989 };
1990
1991 static const struct evlist_test test__hybrid_events[] = {
1992         {
1993                 .name  = "cpu_core/cpu-cycles/",
1994                 .check = test__hybrid_hw_event_with_pmu,
1995                 /* 0 */
1996         },
1997         {
1998                 .name  = "{cpu_core/cpu-cycles/,cpu_core/instructions/}",
1999                 .check = test__hybrid_hw_group_event,
2000                 /* 1 */
2001         },
2002         {
2003                 .name  = "{cpu-clock,cpu_core/cpu-cycles/}",
2004                 .check = test__hybrid_sw_hw_group_event,
2005                 /* 2 */
2006         },
2007         {
2008                 .name  = "{cpu_core/cpu-cycles/,cpu-clock}",
2009                 .check = test__hybrid_hw_sw_group_event,
2010                 /* 3 */
2011         },
2012         {
2013                 .name  = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}",
2014                 .check = test__hybrid_group_modifier1,
2015                 /* 4 */
2016         },
2017         {
2018                 .name  = "r1a",
2019                 .check = test__hybrid_raw1,
2020                 /* 5 */
2021         },
2022         {
2023                 .name  = "cpu_core/r1a/",
2024                 .check = test__hybrid_raw2,
2025                 /* 6 */
2026         },
2027         {
2028                 .name  = "cpu_core/config=10,config1,config2=3,period=1000/u",
2029                 .check = test__checkevent_pmu,
2030                 /* 7 */
2031         },
2032         {
2033                 .name  = "cpu_core/LLC-loads/",
2034                 .check = test__hybrid_cache_event,
2035                 /* 8 */
2036         },
2037 };
2038
2039 static int test_event(const struct evlist_test *e)
2040 {
2041         struct parse_events_error err;
2042         struct evlist *evlist;
2043         int ret;
2044
2045         if (e->valid && !e->valid()) {
2046                 pr_debug("... SKIP\n");
2047                 return TEST_OK;
2048         }
2049
2050         evlist = evlist__new();
2051         if (evlist == NULL) {
2052                 pr_err("Failed allocation");
2053                 return TEST_FAIL;
2054         }
2055         parse_events_error__init(&err);
2056         ret = parse_events(evlist, e->name, &err);
2057         if (ret) {
2058                 pr_debug("failed to parse event '%s', err %d, str '%s'\n",
2059                          e->name, ret, err.str);
2060                 parse_events_error__print(&err, e->name);
2061                 ret = TEST_FAIL;
2062                 if (strstr(err.str, "can't access trace events"))
2063                         ret = TEST_SKIP;
2064         } else {
2065                 ret = e->check(evlist);
2066         }
2067         parse_events_error__exit(&err);
2068         evlist__delete(evlist);
2069
2070         return ret;
2071 }
2072
2073 static int test_event_fake_pmu(const char *str)
2074 {
2075         struct parse_events_error err;
2076         struct evlist *evlist;
2077         int ret;
2078
2079         evlist = evlist__new();
2080         if (!evlist)
2081                 return -ENOMEM;
2082
2083         parse_events_error__init(&err);
2084         perf_pmu__test_parse_init();
2085         ret = __parse_events(evlist, str, &err, &perf_pmu__fake);
2086         if (ret) {
2087                 pr_debug("failed to parse event '%s', err %d, str '%s'\n",
2088                          str, ret, err.str);
2089                 parse_events_error__print(&err, str);
2090         }
2091
2092         parse_events_error__exit(&err);
2093         evlist__delete(evlist);
2094
2095         return ret;
2096 }
2097
2098 static int combine_test_results(int existing, int latest)
2099 {
2100         if (existing == TEST_FAIL)
2101                 return TEST_FAIL;
2102         if (existing == TEST_SKIP)
2103                 return latest == TEST_OK ? TEST_SKIP : latest;
2104         return latest;
2105 }
2106
2107 static int test_events(const struct evlist_test *events, int cnt)
2108 {
2109         int ret = TEST_OK;
2110
2111         for (int i = 0; i < cnt; i++) {
2112                 const struct evlist_test *e = &events[i];
2113                 int test_ret;
2114
2115                 pr_debug("running test %d '%s'\n", i, e->name);
2116                 test_ret = test_event(e);
2117                 if (test_ret != TEST_OK) {
2118                         pr_debug("Event test failure: test %d '%s'", i, e->name);
2119                         ret = combine_test_results(ret, test_ret);
2120                 }
2121         }
2122
2123         return ret;
2124 }
2125
2126 static int test__events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2127 {
2128         return test_events(test__events, ARRAY_SIZE(test__events));
2129 }
2130
2131 static int test_term(const struct terms_test *t)
2132 {
2133         struct list_head terms;
2134         int ret;
2135
2136         INIT_LIST_HEAD(&terms);
2137
2138         /*
2139          * The perf_pmu__test_parse_init prepares perf_pmu_events_list
2140          * which gets freed in parse_events_terms.
2141          */
2142         if (perf_pmu__test_parse_init())
2143                 return -1;
2144
2145         ret = parse_events_terms(&terms, t->str);
2146         if (ret) {
2147                 pr_debug("failed to parse terms '%s', err %d\n",
2148                          t->str , ret);
2149                 return ret;
2150         }
2151
2152         ret = t->check(&terms);
2153         parse_events_terms__purge(&terms);
2154
2155         return ret;
2156 }
2157
2158 static int test_terms(const struct terms_test *terms, int cnt)
2159 {
2160         int ret = 0;
2161
2162         for (int i = 0; i < cnt; i++) {
2163                 const struct terms_test *t = &terms[i];
2164
2165                 pr_debug("running test %d '%s'\n", i, t->str);
2166                 ret = test_term(t);
2167                 if (ret)
2168                         break;
2169         }
2170
2171         return ret;
2172 }
2173
2174 static int test__terms2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2175 {
2176         return test_terms(test__terms, ARRAY_SIZE(test__terms));
2177 }
2178
2179 static int test_pmu(void)
2180 {
2181         struct stat st;
2182         char path[PATH_MAX];
2183         int ret;
2184
2185         snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/format/",
2186                  sysfs__mountpoint());
2187
2188         ret = stat(path, &st);
2189         if (ret)
2190                 pr_debug("omitting PMU cpu tests\n");
2191         return !ret;
2192 }
2193
2194 static int test__pmu_events(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2195 {
2196         struct stat st;
2197         char path[PATH_MAX];
2198         struct dirent *ent;
2199         DIR *dir;
2200         int ret;
2201
2202         if (!test_pmu())
2203                 return TEST_SKIP;
2204
2205         snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/events/",
2206                  sysfs__mountpoint());
2207
2208         ret = stat(path, &st);
2209         if (ret) {
2210                 pr_debug("omitting PMU cpu events tests: %s\n", path);
2211                 return TEST_OK;
2212         }
2213
2214         dir = opendir(path);
2215         if (!dir) {
2216                 pr_debug("can't open pmu event dir: %s\n", path);
2217                 return TEST_FAIL;
2218         }
2219
2220         ret = TEST_OK;
2221         while ((ent = readdir(dir))) {
2222                 struct evlist_test e = { .name = NULL, };
2223                 char name[2 * NAME_MAX + 1 + 12 + 3];
2224                 int test_ret;
2225
2226                 /* Names containing . are special and cannot be used directly */
2227                 if (strchr(ent->d_name, '.'))
2228                         continue;
2229
2230                 snprintf(name, sizeof(name), "cpu/event=%s/u", ent->d_name);
2231
2232                 e.name  = name;
2233                 e.check = test__checkevent_pmu_events;
2234
2235                 test_ret = test_event(&e);
2236                 if (test_ret != TEST_OK) {
2237                         pr_debug("Test PMU event failed for '%s'", name);
2238                         ret = combine_test_results(ret, test_ret);
2239                 }
2240                 snprintf(name, sizeof(name), "%s:u,cpu/event=%s/u", ent->d_name, ent->d_name);
2241                 e.name  = name;
2242                 e.check = test__checkevent_pmu_events_mix;
2243                 test_ret = test_event(&e);
2244                 if (test_ret != TEST_OK) {
2245                         pr_debug("Test PMU event failed for '%s'", name);
2246                         ret = combine_test_results(ret, test_ret);
2247                 }
2248         }
2249
2250         closedir(dir);
2251         return ret;
2252 }
2253
2254 static int test__pmu_events2(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2255 {
2256         if (!test_pmu())
2257                 return TEST_SKIP;
2258
2259         return test_events(test__events_pmu, ARRAY_SIZE(test__events_pmu));
2260 }
2261
2262 static bool test_alias(char **event, char **alias)
2263 {
2264         char path[PATH_MAX];
2265         DIR *dir;
2266         struct dirent *dent;
2267         const char *sysfs = sysfs__mountpoint();
2268         char buf[128];
2269         FILE *file;
2270
2271         if (!sysfs)
2272                 return false;
2273
2274         snprintf(path, PATH_MAX, "%s/bus/event_source/devices/", sysfs);
2275         dir = opendir(path);
2276         if (!dir)
2277                 return false;
2278
2279         while ((dent = readdir(dir))) {
2280                 if (!strcmp(dent->d_name, ".") ||
2281                     !strcmp(dent->d_name, ".."))
2282                         continue;
2283
2284                 snprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/alias",
2285                          sysfs, dent->d_name);
2286
2287                 if (!file_available(path))
2288                         continue;
2289
2290                 file = fopen(path, "r");
2291                 if (!file)
2292                         continue;
2293
2294                 if (!fgets(buf, sizeof(buf), file)) {
2295                         fclose(file);
2296                         continue;
2297                 }
2298
2299                 /* Remove the last '\n' */
2300                 buf[strlen(buf) - 1] = 0;
2301
2302                 fclose(file);
2303                 *event = strdup(dent->d_name);
2304                 *alias = strdup(buf);
2305                 closedir(dir);
2306
2307                 if (*event == NULL || *alias == NULL) {
2308                         free(*event);
2309                         free(*alias);
2310                         return false;
2311                 }
2312
2313                 return true;
2314         }
2315
2316         closedir(dir);
2317         return false;
2318 }
2319
2320 static int test__hybrid(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2321 {
2322         if (!perf_pmu__has_hybrid())
2323                 return TEST_SKIP;
2324
2325         return test_events(test__hybrid_events, ARRAY_SIZE(test__hybrid_events));
2326 }
2327
2328 static int test__checkevent_pmu_events_alias(struct evlist *evlist)
2329 {
2330         struct evsel *evsel1 = evlist__first(evlist);
2331         struct evsel *evsel2 = evlist__last(evlist);
2332
2333         TEST_ASSERT_VAL("wrong type", evsel1->core.attr.type == evsel2->core.attr.type);
2334         TEST_ASSERT_VAL("wrong config", evsel1->core.attr.config == evsel2->core.attr.config);
2335         return TEST_OK;
2336 }
2337
2338 static int test__pmu_events_alias(char *event, char *alias)
2339 {
2340         struct evlist_test e = { .name = NULL, };
2341         char name[2 * NAME_MAX + 20];
2342
2343         snprintf(name, sizeof(name), "%s/event=1/,%s/event=1/",
2344                  event, alias);
2345
2346         e.name  = name;
2347         e.check = test__checkevent_pmu_events_alias;
2348         return test_event(&e);
2349 }
2350
2351 static int test__alias(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
2352 {
2353         char *event, *alias;
2354         int ret;
2355
2356         if (!test_alias(&event, &alias))
2357                 return TEST_SKIP;
2358
2359         ret = test__pmu_events_alias(event, alias);
2360
2361         free(event);
2362         free(alias);
2363         return ret;
2364 }
2365
2366 static int test__pmu_events_alias2(struct test_suite *test __maybe_unused,
2367                                    int subtest __maybe_unused)
2368 {
2369         static const char events[][30] = {
2370                         "event-hyphen",
2371                         "event-two-hyph",
2372         };
2373         int ret = TEST_OK;
2374
2375         for (unsigned int i = 0; i < ARRAY_SIZE(events); i++) {
2376                 int test_ret = test_event_fake_pmu(&events[i][0]);
2377
2378                 if (test_ret != TEST_OK) {
2379                         pr_debug("check_parse_fake %s failed\n", &events[i][0]);
2380                         ret = combine_test_results(ret, test_ret);
2381                 }
2382         }
2383
2384         return ret;
2385 }
2386
2387 static struct test_case tests__parse_events[] = {
2388         TEST_CASE_REASON("Test event parsing",
2389                          events2,
2390                          "permissions"),
2391         TEST_CASE_REASON("Test parsing of \"hybrid\" CPU events",
2392                          hybrid,
2393                         "not hybrid"),
2394         TEST_CASE_REASON("Parsing of all PMU events from sysfs",
2395                          pmu_events,
2396                          "permissions"),
2397         TEST_CASE_REASON("Parsing of given PMU events from sysfs",
2398                          pmu_events2,
2399                          "permissions"),
2400         TEST_CASE_REASON("Parsing of aliased events from sysfs", alias,
2401                          "no aliases in sysfs"),
2402         TEST_CASE("Parsing of aliased events", pmu_events_alias2),
2403         TEST_CASE("Parsing of terms (event modifiers)", terms2),
2404         {       .name = NULL, }
2405 };
2406
2407 struct test_suite suite__parse_events = {
2408         .desc = "Parse event definition strings",
2409         .test_cases = tests__parse_events,
2410 };