tools/perf/tests/hists_output.c

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