tools/perf/tests/hists_output.c

   1 #include "perf.h"
   2 #include "util/debug.h"
   3 #include "util/symbol.h"
   4 #include "util/sort.h"
   5 #include "util/evsel.h"
   6 #include "util/evlist.h"
   7 #include "util/machine.h"
   8 #include "util/thread.h"
   9 #include "util/parse-events.h"
  10 #include "tests/tests.h"
  11 #include "tests/hists_common.h"
  12
  13 struct sample {
  14         u32 cpu;
  15         u32 pid;
  16         u64 ip;
  17         struct thread *thread;
  18         struct map *map;
  19         struct symbol *sym;
  20 };
  21
  22 /* For the numbers, see hists_common.c */
  23 static struct sample fake_samples[] = {
  24         /* perf [kernel] schedule() */
  25         { .cpu = 0, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
  26         /* perf [perf]   main() */
  27         { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
  28         /* perf [perf]   cmd_record() */
  29         { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
  30         /* perf [libc]   malloc() */
  31         { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
  32         /* perf [libc]   free() */
  33         { .cpu = 2, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
  34         /* perf [perf]   main() */
  35         { .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
  36         /* perf [kernel] page_fault() */
  37         { .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
  38         /* bash [bash]   main() */
  39         { .cpu = 3, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_MAIN, },
  40         /* bash [bash]   xmalloc() */
  41         { .cpu = 0, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XMALLOC, },
  42         /* bash [kernel] page_fault() */
  43         { .cpu = 1, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
  44 };
  45
  46 static int add_hist_entries(struct hists *hists, struct machine *machine)
  47 {
  48         struct addr_location al;
  49         struct perf_evsel *evsel = hists_to_evsel(hists);
  50         struct perf_sample sample = { .period = 100, };
  51         size_t i;
  52
  53         for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
  54                 struct hist_entry_iter iter = {
  55                         .evsel = evsel,
  56                         .sample = &sample,
  57                         .ops = &hist_iter_normal,
  58                         .hide_unresolved = false,
  59                 };
  60
  61                 sample.cpumode = PERF_RECORD_MISC_USER;
  62                 sample.cpu = fake_samples[i].cpu;
  63                 sample.pid = fake_samples[i].pid;
  64                 sample.tid = fake_samples[i].pid;
  65                 sample.ip = fake_samples[i].ip;
  66
  67                 if (machine__resolve(machine, &al, &sample) < 0)
  68                         goto out;
  69
  70                 if (hist_entry_iter__add(&iter, &al, PERF_MAX_STACK_DEPTH,
  71                                          NULL) < 0) {
  72                         addr_location__put(&al);
  73                         goto out;
  74                 }
  75
  76                 fake_samples[i].thread = al.thread;
  77                 fake_samples[i].map = al.map;
  78                 fake_samples[i].sym = al.sym;
  79         }
  80
  81         return TEST_OK;
  82
  83 out:
  84         pr_debug("Not enough memory for adding a hist entry\n");
  85         return TEST_FAIL;
  86 }
  87
  88 static void del_hist_entries(struct hists *hists)
  89 {
  90         struct hist_entry *he;
  91         struct rb_root *root_in;
  92         struct rb_root *root_out;
  93         struct rb_node *node;
  94
  95         if (sort__need_collapse)
  96                 root_in = &hists->entries_collapsed;
  97         else
  98                 root_in = hists->entries_in;
  99
 100         root_out = &hists->entries;
 101
 102         while (!RB_EMPTY_ROOT(root_out)) {
 103                 node = rb_first(root_out);
 104
 105                 he = rb_entry(node, struct hist_entry, rb_node);
 106                 rb_erase(node, root_out);
 107                 rb_erase(&he->rb_node_in, root_in);
 108                 hist_entry__delete(he);
 109         }
 110 }
 111
 112 typedef int (*test_fn_t)(struct perf_evsel *, struct machine *);
 113
 114 #define COMM(he)  (thread__comm_str(he->thread))
 115 #define DSO(he)   (he->ms.map->dso->short_name)
 116 #define SYM(he)   (he->ms.sym->name)
 117 #define CPU(he)   (he->cpu)
 118 #define PID(he)   (he->thread->tid)
 119
 120 /* default sort keys (no field) */
 121 static int test1(struct perf_evsel *evsel, struct machine *machine)
 122 {
 123         int err;
 124         struct hists *hists = evsel__hists(evsel);
 125         struct hist_entry *he;
 126         struct rb_root *root;
 127         struct rb_node *node;
 128
 129         field_order = NULL;
 130         sort_order = NULL; /* equivalent to sort_order = "comm,dso,sym" */
 131
 132         setup_sorting(NULL);
 133
 134         /*
 135          * expected output:
 136          *
 137          * Overhead  Command  Shared Object          Symbol
 138          * ========  =======  =============  ==============
 139          *   20.00%     perf  perf           [.] main
 140          *   10.00%     bash  [kernel]       [k] page_fault
 141          *   10.00%     bash  bash           [.] main
 142          *   10.00%     bash  bash           [.] xmalloc
 143          *   10.00%     perf  [kernel]       [k] page_fault
 144          *   10.00%     perf  [kernel]       [k] schedule
 145          *   10.00%     perf  libc           [.] free
 146          *   10.00%     perf  libc           [.] malloc
 147          *   10.00%     perf  perf           [.] cmd_record
 148          */
 149         err = add_hist_entries(hists, machine);
 150         if (err < 0)
 151                 goto out;
 152
 153         hists__collapse_resort(hists, NULL);
 154         perf_evsel__output_resort(evsel, NULL);
 155
 156         if (verbose > 2) {
 157                 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
 158                 print_hists_out(hists);
 159         }
 160
 161         root = &hists->entries;
 162         node = rb_first(root);
 163         he = rb_entry(node, struct hist_entry, rb_node);
 164         TEST_ASSERT_VAL("Invalid hist entry",
 165                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 166                         !strcmp(SYM(he), "main") && he->stat.period == 200);
 167
 168         node = rb_next(node);
 169         he = rb_entry(node, struct hist_entry, rb_node);
 170         TEST_ASSERT_VAL("Invalid hist entry",
 171                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
 172                         !strcmp(SYM(he), "page_fault") && he->stat.period == 100);
 173
 174         node = rb_next(node);
 175         he = rb_entry(node, struct hist_entry, rb_node);
 176         TEST_ASSERT_VAL("Invalid hist entry",
 177                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
 178                         !strcmp(SYM(he), "main") && he->stat.period == 100);
 179
 180         node = rb_next(node);
 181         he = rb_entry(node, struct hist_entry, rb_node);
 182         TEST_ASSERT_VAL("Invalid hist entry",
 183                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
 184                         !strcmp(SYM(he), "xmalloc") && he->stat.period == 100);
 185
 186         node = rb_next(node);
 187         he = rb_entry(node, struct hist_entry, rb_node);
 188         TEST_ASSERT_VAL("Invalid hist entry",
 189                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
 190                         !strcmp(SYM(he), "page_fault") && he->stat.period == 100);
 191
 192         node = rb_next(node);
 193         he = rb_entry(node, struct hist_entry, rb_node);
 194         TEST_ASSERT_VAL("Invalid hist entry",
 195                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
 196                         !strcmp(SYM(he), "schedule") && he->stat.period == 100);
 197
 198         node = rb_next(node);
 199         he = rb_entry(node, struct hist_entry, rb_node);
 200         TEST_ASSERT_VAL("Invalid hist entry",
 201                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
 202                         !strcmp(SYM(he), "free") && he->stat.period == 100);
 203
 204         node = rb_next(node);
 205         he = rb_entry(node, struct hist_entry, rb_node);
 206         TEST_ASSERT_VAL("Invalid hist entry",
 207                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
 208                         !strcmp(SYM(he), "malloc") && he->stat.period == 100);
 209
 210         node = rb_next(node);
 211         he = rb_entry(node, struct hist_entry, rb_node);
 212         TEST_ASSERT_VAL("Invalid hist entry",
 213                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 214                         !strcmp(SYM(he), "cmd_record") && he->stat.period == 100);
 215
 216 out:
 217         del_hist_entries(hists);
 218         reset_output_field();
 219         return err;
 220 }
 221
 222 /* mixed fields and sort keys */
 223 static int test2(struct perf_evsel *evsel, struct machine *machine)
 224 {
 225         int err;
 226         struct hists *hists = evsel__hists(evsel);
 227         struct hist_entry *he;
 228         struct rb_root *root;
 229         struct rb_node *node;
 230
 231         field_order = "overhead,cpu";
 232         sort_order = "pid";
 233
 234         setup_sorting(NULL);
 235
 236         /*
 237          * expected output:
 238          *
 239          * Overhead  CPU  Command:  Pid
 240          * ========  ===  =============
 241          *   30.00%    1  perf   :  100
 242          *   10.00%    0  perf   :  100
 243          *   10.00%    2  perf   :  100
 244          *   20.00%    2  perf   :  200
 245          *   10.00%    0  bash   :  300
 246          *   10.00%    1  bash   :  300
 247          *   10.00%    3  bash   :  300
 248          */
 249         err = add_hist_entries(hists, machine);
 250         if (err < 0)
 251                 goto out;
 252
 253         hists__collapse_resort(hists, NULL);
 254         perf_evsel__output_resort(evsel, NULL);
 255
 256         if (verbose > 2) {
 257                 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
 258                 print_hists_out(hists);
 259         }
 260
 261         root = &hists->entries;
 262         node = rb_first(root);
 263         he = rb_entry(node, struct hist_entry, rb_node);
 264         TEST_ASSERT_VAL("Invalid hist entry",
 265                         CPU(he) == 1 && PID(he) == 100 && he->stat.period == 300);
 266
 267         node = rb_next(node);
 268         he = rb_entry(node, struct hist_entry, rb_node);
 269         TEST_ASSERT_VAL("Invalid hist entry",
 270                         CPU(he) == 0 && PID(he) == 100 && he->stat.period == 100);
 271
 272 out:
 273         del_hist_entries(hists);
 274         reset_output_field();
 275         return err;
 276 }
 277
 278 /* fields only (no sort key) */
 279 static int test3(struct perf_evsel *evsel, struct machine *machine)
 280 {
 281         int err;
 282         struct hists *hists = evsel__hists(evsel);
 283         struct hist_entry *he;
 284         struct rb_root *root;
 285         struct rb_node *node;
 286
 287         field_order = "comm,overhead,dso";
 288         sort_order = NULL;
 289
 290         setup_sorting(NULL);
 291
 292         /*
 293          * expected output:
 294          *
 295          * Command  Overhead  Shared Object
 296          * =======  ========  =============
 297          *    bash    20.00%  bash
 298          *    bash    10.00%  [kernel]
 299          *    perf    30.00%  perf
 300          *    perf    20.00%  [kernel]
 301          *    perf    20.00%  libc
 302          */
 303         err = add_hist_entries(hists, machine);
 304         if (err < 0)
 305                 goto out;
 306
 307         hists__collapse_resort(hists, NULL);
 308         perf_evsel__output_resort(evsel, NULL);
 309
 310         if (verbose > 2) {
 311                 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
 312                 print_hists_out(hists);
 313         }
 314
 315         root = &hists->entries;
 316         node = rb_first(root);
 317         he = rb_entry(node, struct hist_entry, rb_node);
 318         TEST_ASSERT_VAL("Invalid hist entry",
 319                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
 320                         he->stat.period == 200);
 321
 322         node = rb_next(node);
 323         he = rb_entry(node, struct hist_entry, rb_node);
 324         TEST_ASSERT_VAL("Invalid hist entry",
 325                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
 326                         he->stat.period == 100);
 327
 328         node = rb_next(node);
 329         he = rb_entry(node, struct hist_entry, rb_node);
 330         TEST_ASSERT_VAL("Invalid hist entry",
 331                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 332                         he->stat.period == 300);
 333
 334         node = rb_next(node);
 335         he = rb_entry(node, struct hist_entry, rb_node);
 336         TEST_ASSERT_VAL("Invalid hist entry",
 337                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
 338                         he->stat.period == 200);
 339
 340         node = rb_next(node);
 341         he = rb_entry(node, struct hist_entry, rb_node);
 342         TEST_ASSERT_VAL("Invalid hist entry",
 343                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
 344                         he->stat.period == 200);
 345
 346 out:
 347         del_hist_entries(hists);
 348         reset_output_field();
 349         return err;
 350 }
 351
 352 /* handle duplicate 'dso' field */
 353 static int test4(struct perf_evsel *evsel, struct machine *machine)
 354 {
 355         int err;
 356         struct hists *hists = evsel__hists(evsel);
 357         struct hist_entry *he;
 358         struct rb_root *root;
 359         struct rb_node *node;
 360
 361         field_order = "dso,sym,comm,overhead,dso";
 362         sort_order = "sym";
 363
 364         setup_sorting(NULL);
 365
 366         /*
 367          * expected output:
 368          *
 369          * Shared Object          Symbol  Command  Overhead
 370          * =============  ==============  =======  ========
 371          *          perf  [.] cmd_record     perf    10.00%
 372          *          libc  [.] free           perf    10.00%
 373          *          bash  [.] main           bash    10.00%
 374          *          perf  [.] main           perf    20.00%
 375          *          libc  [.] malloc         perf    10.00%
 376          *      [kernel]  [k] page_fault     bash    10.00%
 377          *      [kernel]  [k] page_fault     perf    10.00%
 378          *      [kernel]  [k] schedule       perf    10.00%
 379          *          bash  [.] xmalloc        bash    10.00%
 380          */
 381         err = add_hist_entries(hists, machine);
 382         if (err < 0)
 383                 goto out;
 384
 385         hists__collapse_resort(hists, NULL);
 386         perf_evsel__output_resort(evsel, NULL);
 387
 388         if (verbose > 2) {
 389                 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
 390                 print_hists_out(hists);
 391         }
 392
 393         root = &hists->entries;
 394         node = rb_first(root);
 395         he = rb_entry(node, struct hist_entry, rb_node);
 396         TEST_ASSERT_VAL("Invalid hist entry",
 397                         !strcmp(DSO(he), "perf") && !strcmp(SYM(he), "cmd_record") &&
 398                         !strcmp(COMM(he), "perf") && he->stat.period == 100);
 399
 400         node = rb_next(node);
 401         he = rb_entry(node, struct hist_entry, rb_node);
 402         TEST_ASSERT_VAL("Invalid hist entry",
 403                         !strcmp(DSO(he), "libc") && !strcmp(SYM(he), "free") &&
 404                         !strcmp(COMM(he), "perf") && he->stat.period == 100);
 405
 406         node = rb_next(node);
 407         he = rb_entry(node, struct hist_entry, rb_node);
 408         TEST_ASSERT_VAL("Invalid hist entry",
 409                         !strcmp(DSO(he), "bash") && !strcmp(SYM(he), "main") &&
 410                         !strcmp(COMM(he), "bash") && he->stat.period == 100);
 411
 412         node = rb_next(node);
 413         he = rb_entry(node, struct hist_entry, rb_node);
 414         TEST_ASSERT_VAL("Invalid hist entry",
 415                         !strcmp(DSO(he), "perf") && !strcmp(SYM(he), "main") &&
 416                         !strcmp(COMM(he), "perf") && he->stat.period == 200);
 417
 418         node = rb_next(node);
 419         he = rb_entry(node, struct hist_entry, rb_node);
 420         TEST_ASSERT_VAL("Invalid hist entry",
 421                         !strcmp(DSO(he), "libc") && !strcmp(SYM(he), "malloc") &&
 422                         !strcmp(COMM(he), "perf") && he->stat.period == 100);
 423
 424         node = rb_next(node);
 425         he = rb_entry(node, struct hist_entry, rb_node);
 426         TEST_ASSERT_VAL("Invalid hist entry",
 427                         !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
 428                         !strcmp(COMM(he), "bash") && he->stat.period == 100);
 429
 430         node = rb_next(node);
 431         he = rb_entry(node, struct hist_entry, rb_node);
 432         TEST_ASSERT_VAL("Invalid hist entry",
 433                         !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
 434                         !strcmp(COMM(he), "perf") && he->stat.period == 100);
 435
 436         node = rb_next(node);
 437         he = rb_entry(node, struct hist_entry, rb_node);
 438         TEST_ASSERT_VAL("Invalid hist entry",
 439                         !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "schedule") &&
 440                         !strcmp(COMM(he), "perf") && he->stat.period == 100);
 441
 442         node = rb_next(node);
 443         he = rb_entry(node, struct hist_entry, rb_node);
 444         TEST_ASSERT_VAL("Invalid hist entry",
 445                         !strcmp(DSO(he), "bash") && !strcmp(SYM(he), "xmalloc") &&
 446                         !strcmp(COMM(he), "bash") && he->stat.period == 100);
 447
 448 out:
 449         del_hist_entries(hists);
 450         reset_output_field();
 451         return err;
 452 }
 453
 454 /* full sort keys w/o overhead field */
 455 static int test5(struct perf_evsel *evsel, struct machine *machine)
 456 {
 457         int err;
 458         struct hists *hists = evsel__hists(evsel);
 459         struct hist_entry *he;
 460         struct rb_root *root;
 461         struct rb_node *node;
 462
 463         field_order = "cpu,pid,comm,dso,sym";
 464         sort_order = "dso,pid";
 465
 466         setup_sorting(NULL);
 467
 468         /*
 469          * expected output:
 470          *
 471          * CPU  Command:  Pid  Command  Shared Object          Symbol
 472          * ===  =============  =======  =============  ==============
 473          *   0     perf:  100     perf       [kernel]  [k] schedule
 474          *   2     perf:  200     perf       [kernel]  [k] page_fault
 475          *   1     bash:  300     bash       [kernel]  [k] page_fault
 476          *   0     bash:  300     bash           bash  [.] xmalloc
 477          *   3     bash:  300     bash           bash  [.] main
 478          *   1     perf:  100     perf           libc  [.] malloc
 479          *   2     perf:  100     perf           libc  [.] free
 480          *   1     perf:  100     perf           perf  [.] cmd_record
 481          *   1     perf:  100     perf           perf  [.] main
 482          *   2     perf:  200     perf           perf  [.] main
 483          */
 484         err = add_hist_entries(hists, machine);
 485         if (err < 0)
 486                 goto out;
 487
 488         hists__collapse_resort(hists, NULL);
 489         perf_evsel__output_resort(evsel, NULL);
 490
 491         if (verbose > 2) {
 492                 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
 493                 print_hists_out(hists);
 494         }
 495
 496         root = &hists->entries;
 497         node = rb_first(root);
 498         he = rb_entry(node, struct hist_entry, rb_node);
 499
 500         TEST_ASSERT_VAL("Invalid hist entry",
 501                         CPU(he) == 0 && PID(he) == 100 &&
 502                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
 503                         !strcmp(SYM(he), "schedule") && he->stat.period == 100);
 504
 505         node = rb_next(node);
 506         he = rb_entry(node, struct hist_entry, rb_node);
 507         TEST_ASSERT_VAL("Invalid hist entry",
 508                         CPU(he) == 2 && PID(he) == 200 &&
 509                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
 510                         !strcmp(SYM(he), "page_fault") && he->stat.period == 100);
 511
 512         node = rb_next(node);
 513         he = rb_entry(node, struct hist_entry, rb_node);
 514         TEST_ASSERT_VAL("Invalid hist entry",
 515                         CPU(he) == 1 && PID(he) == 300 &&
 516                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
 517                         !strcmp(SYM(he), "page_fault") && he->stat.period == 100);
 518
 519         node = rb_next(node);
 520         he = rb_entry(node, struct hist_entry, rb_node);
 521         TEST_ASSERT_VAL("Invalid hist entry",
 522                         CPU(he) == 0 && PID(he) == 300 &&
 523                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
 524                         !strcmp(SYM(he), "xmalloc") && he->stat.period == 100);
 525
 526         node = rb_next(node);
 527         he = rb_entry(node, struct hist_entry, rb_node);
 528         TEST_ASSERT_VAL("Invalid hist entry",
 529                         CPU(he) == 3 && PID(he) == 300 &&
 530                         !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
 531                         !strcmp(SYM(he), "main") && he->stat.period == 100);
 532
 533         node = rb_next(node);
 534         he = rb_entry(node, struct hist_entry, rb_node);
 535         TEST_ASSERT_VAL("Invalid hist entry",
 536                         CPU(he) == 1 && PID(he) == 100 &&
 537                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
 538                         !strcmp(SYM(he), "malloc") && he->stat.period == 100);
 539
 540         node = rb_next(node);
 541         he = rb_entry(node, struct hist_entry, rb_node);
 542         TEST_ASSERT_VAL("Invalid hist entry",
 543                         CPU(he) == 2 && PID(he) == 100 &&
 544                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
 545                         !strcmp(SYM(he), "free") && he->stat.period == 100);
 546
 547         node = rb_next(node);
 548         he = rb_entry(node, struct hist_entry, rb_node);
 549         TEST_ASSERT_VAL("Invalid hist entry",
 550                         CPU(he) == 1 && PID(he) == 100 &&
 551                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 552                         !strcmp(SYM(he), "cmd_record") && he->stat.period == 100);
 553
 554         node = rb_next(node);
 555         he = rb_entry(node, struct hist_entry, rb_node);
 556         TEST_ASSERT_VAL("Invalid hist entry",
 557                         CPU(he) == 1 && PID(he) == 100 &&
 558                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 559                         !strcmp(SYM(he), "main") && he->stat.period == 100);
 560
 561         node = rb_next(node);
 562         he = rb_entry(node, struct hist_entry, rb_node);
 563         TEST_ASSERT_VAL("Invalid hist entry",
 564                         CPU(he) == 2 && PID(he) == 200 &&
 565                         !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
 566                         !strcmp(SYM(he), "main") && he->stat.period == 100);
 567
 568 out:
 569         del_hist_entries(hists);
 570         reset_output_field();
 571         return err;
 572 }
 573
 574 int test__hists_output(int subtest __maybe_unused)
 575 {
 576         int err = TEST_FAIL;
 577         struct machines machines;
 578         struct machine *machine;
 579         struct perf_evsel *evsel;
 580         struct perf_evlist *evlist = perf_evlist__new();
 581         size_t i;
 582         test_fn_t testcases[] = {
 583                 test1,
 584                 test2,
 585                 test3,
 586                 test4,
 587                 test5,
 588         };
 589
 590         TEST_ASSERT_VAL("No memory", evlist);
 591
 592         err = parse_events(evlist, "cpu-clock", NULL);
 593         if (err)
 594                 goto out;
 595         err = TEST_FAIL;
 596
 597         machines__init(&machines);
 598
 599         /* setup threads/dso/map/symbols also */
 600         machine = setup_fake_machine(&machines);
 601         if (!machine)
 602                 goto out;
 603
 604         if (verbose > 1)
 605                 machine__fprintf(machine, stderr);
 606
 607         evsel = perf_evlist__first(evlist);
 608
 609         for (i = 0; i < ARRAY_SIZE(testcases); i++) {
 610                 err = testcases[i](evsel, machine);
 611                 if (err < 0)
 612                         break;
 613         }
 614
 615 out:
 616         /* tear down everything */
 617         perf_evlist__delete(evlist);
 618         machines__exit(&machines);
 619
 620         return err;
 621 }