src/utils_proc_pids_test.c

   1 #include "testing.h"
   2 #include "utils_proc_pids.c" /* sic */
   3 #include <sys/stat.h>
   4
   5 /***************************************************************************
   6  * helper functions
   7  */
   8
   9 /*
  10  * NAME
  11  *   pids_list_get_element
  12  *
  13  * DESCRIPTION
  14  *   Gets list element at index position. Assumes list was created by
  15  *   pids_list_add_pid function.
  16  *
  17  * PARAMETERS
  18  *   `list'      Pids list
  19  *   `index'     Position of desired element relative to given list pointer.
  20  *
  21  * RETURN VALUE
  22  *   Pointer to element at index position.
  23  *   NULL if index exceeds list's length.
  24  */
  25 pids_list_t *pids_list_get_element(pids_list_t *list, const size_t index) {
  26   assert(list);
  27   size_t current = 0;
  28   while (list != NULL && current != index) {
  29     list = list->next;
  30     current++;
  31   }
  32   return list;
  33 }
  34
  35 typedef struct stub_proc_pid {
  36   proc_comm_t comm;
  37   pid_t pid;
  38 } stub_proc_pid_t;
  39
  40 static const char *proc_fs = "/tmp/procfs_stub";
  41
  42 /*
  43  * NAME
  44  *   stub_procfs_setup
  45  *
  46  * DESCRIPTION
  47  *   Prepares testing environment by creating temporary
  48  *   PID/comm file structure.
  49  *
  50  * PARAMETERS
  51  *   `proc_pids_array'          Array of stub_proc_pid_t structs. Represents
  52  *                              which PIDs should hold given process name.
  53  *   `proc_pids_array_length'   Element count of input array.
  54  *
  55  * RETURN VALUE
  56  *   0 on success.
  57  *   -1 on base dir creation error.
  58  *   -2 on comm file creation error.
  59  *   -3 on comm file write error.
  60  */
  61 int stub_procfs_setup(const stub_proc_pid_t *proc_pids_array,
  62                       const size_t proc_pids_array_length) {
  63   if (mkdir(proc_fs, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
  64     return -1;
  65   char path[256];
  66
  67   for (size_t i = 0; i < proc_pids_array_length; ++i) {
  68     memset(path, 0, sizeof(path));
  69     snprintf(path, STATIC_ARRAY_SIZE(path), "%s/%d", proc_fs,
  70              proc_pids_array[i].pid);
  71     mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
  72     strncat(path, "/comm", STATIC_ARRAY_SIZE(path) - strlen(path) - 1);
  73
  74     FILE *fp = fopen(path, "w");
  75     if (!fp)
  76       return -2;
  77
  78     size_t slen = strlen(proc_pids_array[i].comm);
  79     size_t wlen = fwrite(proc_pids_array[i].comm, sizeof(char), slen, fp);
  80     fclose(fp);
  81
  82     if (slen != wlen)
  83       return -3;
  84   }
  85   return 0;
  86 }
  87
  88 /*
  89  * NAME
  90  *   stub_procfs_teardown
  91  *
  92  * DESCRIPTION
  93  *   Clears testing environment: removes stub proc files.
  94  *   NOTE - This function could be implemented by usage of nftw, but this
  95  *   would require #define _XOPEN_SOURCE 500, which
  96  *   messes up intel_rdt includes.
  97  *
  98  * RETURN VALUE
  99  *   system command result
 100  */
 101 int stub_procfs_teardown() {
 102   char cmd[256];
 103   sstrncpy(cmd, "rm -rf ", STATIC_ARRAY_SIZE(cmd));
 104   strncat(cmd, proc_fs, STATIC_ARRAY_SIZE(cmd) - strlen(cmd) - 1);
 105   return system(cmd);
 106 }
 107
 108 /* Max PID value. More info:
 109  * http://web.archive.org/web/20111209081734/http://research.cs.wisc.edu/condor/condorg/linux_scalability.html
 110  */
 111 #define MAX_PID 4194304
 112 #define MAX_PID_STR "4194304"
 113
 114 /***************************************************************************
 115  * tests
 116  */
 117 DEF_TEST(initialize_proc_pids__on_nullptr) {
 118   /* setup */
 119   const char *procs_names_array[] = {"proc1", "proc2", "proc3"};
 120   const size_t procs_names_array_size = STATIC_ARRAY_SIZE(procs_names_array);
 121   proc_pids_t *proc_pids_array = NULL;
 122
 123   /* check */
 124   int result = initialize_proc_pids(procs_names_array, procs_names_array_size,
 125                                     &proc_pids_array);
 126   EXPECT_EQ_INT(0, result);
 127   for (size_t i = 0; i < procs_names_array_size; ++i)
 128     EXPECT_EQ_STR(procs_names_array[i], proc_pids_array[i].proccess_name);
 129
 130   /* cleanup */
 131   free(proc_pids_array);
 132   return 0;
 133 }
 134
 135 DEF_TEST(add_proc_pid__empty_list) {
 136   /* setup */
 137   proc_pids_t proc_pids_instance;
 138   proc_pids_instance.pids = NULL;
 139   pid_t pid = 1234;
 140
 141   /* check */
 142   pids_list_add_pid(&proc_pids_instance.pids, pid);
 143   pids_list_t *added = pids_list_get_element(proc_pids_instance.pids, 0);
 144   EXPECT_EQ_INT(pid, added->pid);
 145
 146   /* cleanup */
 147   pids_list_free(proc_pids_instance.pids);
 148   return 0;
 149 }
 150
 151 DEF_TEST(add_proc_pid__non_empty_list) {
 152   /* setup */
 153   proc_pids_t proc_pids_instance;
 154   proc_pids_instance.pids = NULL;
 155   pid_t pids[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 156
 157   /* check */
 158   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i)
 159     pids_list_add_pid(&proc_pids_instance.pids, pids[i]);
 160
 161   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i) {
 162     pids_list_t *added = pids_list_get_element(proc_pids_instance.pids, i);
 163     EXPECT_EQ_INT(pids[i], added->pid);
 164   }
 165
 166   /* cleanup */
 167   pids_list_free(proc_pids_instance.pids);
 168   return 0;
 169 }
 170
 171 DEF_TEST(pids_list_to_array__non_empty_list) {
 172   /* setup */
 173   pid_t pids[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 174   pids_list_t *pids_list = NULL;
 175   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i)
 176     pids_list_add_pid(&pids_list, pids[i]);
 177
 178   /* check */
 179   pid_t target_array[STATIC_ARRAY_SIZE(pids)];
 180   pids_list_to_array(target_array, pids_list, STATIC_ARRAY_SIZE(target_array));
 181   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i)
 182     EXPECT_EQ_INT(pids[i], target_array[i]);
 183
 184   /* cleanup */
 185   pids_list_free(pids_list);
 186   return 0;
 187 }
 188
 189 DEF_TEST(pids_list_add_pids_list__non_empty_lists) {
 190   /* setup */
 191   pid_t pids_array_1[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 192   pid_t pids_array_2[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
 193   pids_list_t *pids_list_1 = NULL;
 194   pids_list_t *pids_list_2 = NULL;
 195   size_t increase = 0;
 196   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_1); ++i) {
 197     pids_list_add_pid(&pids_list_1, pids_array_1[i]);
 198     pids_list_add_pid(&pids_list_2, pids_array_2[i]);
 199   }
 200
 201   /* check */
 202   int result = pids_list_add_pids_list(&pids_list_1, pids_list_2, &increase);
 203   EXPECT_EQ_INT(0, result);
 204   EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_2), increase);
 205
 206   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_1); ++i) {
 207     EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array_1[i]));
 208     EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array_2[i]));
 209   }
 210
 211   /* setup */
 212   pids_list_free(pids_list_1);
 213   pids_list_free(pids_list_2);
 214   return 0;
 215 }
 216
 217 DEF_TEST(pids_list_add_pids_list__add_to_empty) {
 218   /* setup */
 219   pid_t pids_array[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
 220   pids_list_t *pids_list_1 = NULL;
 221   pids_list_t *pids_list_2 = NULL;
 222   size_t increase = 0;
 223   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array); ++i)
 224     pids_list_add_pid(&pids_list_2, pids_array[i]);
 225
 226   /* check */
 227   int result = pids_list_add_pids_list(&pids_list_1, pids_list_2, &increase);
 228   EXPECT_EQ_INT(0, result);
 229   EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array), increase);
 230
 231   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array); ++i)
 232     EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array[i]));
 233
 234   /* setup */
 235   pids_list_free(pids_list_1);
 236   pids_list_free(pids_list_2);
 237   return 0;
 238 }
 239
 240 DEF_TEST(get_pid_number__valid_dir) {
 241   /* setup */
 242   struct dirent d;
 243   sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
 244   d.d_type = DT_DIR;
 245   pid_t pid = 0;
 246
 247   /* check */
 248   int pid_conversion = get_pid_number(&d, &pid);
 249
 250   EXPECT_EQ_INT(0, pid_conversion);
 251   EXPECT_EQ_INT(MAX_PID, pid);
 252
 253   /* cleanup */
 254   return 0;
 255 }
 256
 257 DEF_TEST(get_pid_number__invalid_dir_name) {
 258   /* setup */
 259   struct dirent d;
 260   sstrncpy(d.d_name, "invalid", STATIC_ARRAY_SIZE(d.d_name));
 261   d.d_type = DT_DIR;
 262   pid_t pid = 0;
 263
 264   /* check */
 265   int pid_conversion = get_pid_number(&d, &pid);
 266
 267   EXPECT_EQ_INT(-1, pid_conversion);
 268   EXPECT_EQ_INT(0, pid);
 269
 270   /* cleanup */
 271   return 0;
 272 }
 273
 274 DEF_TEST(read_proc_name__valid_name) {
 275   /* setup */
 276   stub_proc_pid_t pp_stubs[] = {{"proc1", MAX_PID}};
 277   stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
 278   struct dirent d;
 279   sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
 280   d.d_type = DT_DIR;
 281
 282   /* check */
 283   proc_comm_t comm;
 284   int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
 285
 286   EXPECT_EQ_INT(strlen(pp_stubs[0].comm), read_result);
 287   EXPECT_EQ_STR(pp_stubs[0].comm, comm);
 288
 289   /* cleanup */
 290   stub_procfs_teardown();
 291   return 0;
 292 }
 293
 294 DEF_TEST(read_proc_name__invalid_name) {
 295   /* setup */
 296   struct dirent d;
 297   sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
 298   d.d_type = DT_DIR;
 299
 300   /* check */
 301   proc_comm_t comm;
 302   int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
 303
 304   EXPECT_EQ_INT(-1, read_result);
 305
 306   /* cleanup */
 307   return 0;
 308 }
 309
 310 DEF_TEST(fetch_pids_for_procs__one_proc_many_pid) {
 311   /* setup */
 312   const char *proc_names[] = {"proc1"};
 313   stub_proc_pid_t pp_stubs[] = {{"proc1", 1007},
 314                                 {"proc1", 1008},
 315                                 {"proc1", 1009},
 316                                 {"proc2", 1010},
 317                                 {"proc3", 1011}};
 318   stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
 319   proc_pids_t *output = NULL;
 320
 321   /* check */
 322   int result = fetch_pids_for_procs(proc_fs, proc_names,
 323                                     STATIC_ARRAY_SIZE(proc_names), &output);
 324   EXPECT_EQ_INT(0, result);
 325
 326   /* proc name check */
 327   EXPECT_EQ_STR(proc_names[0], output[0].proccess_name);
 328
 329   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pp_stubs); ++i) {
 330     if (0 == strcmp(pp_stubs[i].comm, proc_names[0]))
 331       /* check if proc struct has correct pids */
 332       EXPECT_EQ_INT(pids_list_contains_pid(output[0].pids, pp_stubs[i].pid), 1);
 333     else
 334       /* check if proc struct has no incorrect pids */
 335       EXPECT_EQ_INT(pids_list_contains_pid(output[0].pids, pp_stubs[i].pid), 0);
 336   }
 337
 338   /* cleanup */
 339   for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i)
 340     pids_list_free(output[i].pids);
 341   free(output);
 342   stub_procfs_teardown();
 343   return 0;
 344 }
 345
 346 DEF_TEST(fetch_pids_for_procs__many_proc_many_pid) {
 347   /* setup */
 348   const char *proc_names[] = {"proc1", "proc2", "proc3"};
 349   stub_proc_pid_t pp_stubs[] = {
 350       {"proc1", 1007}, {"proc1", 1008}, {"proc1", 1009}, {"proc2", 2007},
 351       {"proc2", 2008}, {"proc2", 2009}, {"proc3", 3007}, {"proc3", 3008},
 352       {"proc3", 3009}, {"proc4", 4007}, {"proc4", 4008}, {"proc4", 4009},
 353       {"proc5", 5007}, {"proc5", 5008}, {"proc5", 5009}};
 354   stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
 355   proc_pids_t *output = NULL;
 356
 357   /* check */
 358   int result = fetch_pids_for_procs(proc_fs, proc_names,
 359                                     STATIC_ARRAY_SIZE(proc_names), &output);
 360   EXPECT_EQ_INT(0, result);
 361
 362   for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i) {
 363
 364     /* proc name check */
 365     EXPECT_EQ_STR(proc_names[i], output[i].proccess_name);
 366
 367     for (size_t j = 0; j < STATIC_ARRAY_SIZE(pp_stubs); ++j) {
 368       if (0 == strcmp(pp_stubs[j].comm, proc_names[i]))
 369         /* check if proc struct has correct pids */
 370         EXPECT_EQ_INT(pids_list_contains_pid(output[i].pids, pp_stubs[j].pid),
 371                       1);
 372       else
 373         /* check if proc struct has no incorrect pids */
 374         EXPECT_EQ_INT(pids_list_contains_pid(output[i].pids, pp_stubs[j].pid),
 375                       0);
 376     }
 377   }
 378
 379   /* cleanup */
 380   for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i)
 381     pids_list_free(output[i].pids);
 382   free(output);
 383   stub_procfs_teardown();
 384   return 0;
 385 }
 386
 387 DEF_TEST(pids_list_diff__all_changed) {
 388   /* setup */
 389   pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 390   pid_t pids_array_after[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
 391   pids_list_t *pids_list_before = NULL;
 392   pids_list_t *pids_list_after = NULL;
 393   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_after); ++i) {
 394     pids_list_add_pid(&pids_list_before, pids_array_before[i]);
 395     pids_list_add_pid(&pids_list_after, pids_array_after[i]);
 396   }
 397
 398   pids_list_t *new_pids = NULL;
 399   size_t new_pids_count = 0;
 400   pids_list_t *lost_pids = NULL;
 401   size_t lost_pids_count = 0;
 402
 403   /* check */
 404   int result = pids_list_diff(pids_list_before, pids_list_after, &new_pids,
 405                               &new_pids_count, &lost_pids, &lost_pids_count);
 406   EXPECT_EQ_INT(0, result);
 407   EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_before), lost_pids_count);
 408   EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_after), new_pids_count);
 409
 410   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_before); ++i) {
 411     EXPECT_EQ_INT(1, pids_list_contains_pid(new_pids, pids_array_after[i]));
 412     EXPECT_EQ_INT(1, pids_list_contains_pid(lost_pids, pids_array_before[i]));
 413   }
 414
 415   /* cleanup */
 416   pids_list_free(pids_list_before);
 417   pids_list_free(pids_list_after);
 418   pids_list_free(new_pids);
 419   pids_list_free(lost_pids);
 420
 421   return 0;
 422 }
 423
 424 DEF_TEST(pids_list_diff__nothing_changed) {
 425   /* setup */
 426   pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 427   pids_list_t *pids_list_before = NULL;
 428   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_before); ++i) {
 429     pids_list_add_pid(&pids_list_before, pids_array_before[i]);
 430   }
 431
 432   pids_list_t *new_pids = NULL;
 433   size_t new_pids_count = 0;
 434   pids_list_t *lost_pids = NULL;
 435   size_t lost_pids_count = 0;
 436
 437   /* check */
 438   int result = pids_list_diff(pids_list_before, pids_list_before, &new_pids,
 439                               &new_pids_count, &lost_pids, &lost_pids_count);
 440   EXPECT_EQ_INT(0, result);
 441   EXPECT_EQ_INT(0, lost_pids_count);
 442   EXPECT_EQ_INT(0, new_pids_count);
 443   OK(NULL == new_pids);
 444   OK(NULL == lost_pids);
 445
 446   /* cleanup */
 447   pids_list_free(pids_list_before);
 448
 449   return 0;
 450 }
 451
 452 DEF_TEST(pids_list_diff__one_added) {
 453   /* setup */
 454   pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 455   pid_t pids_array_after[] = {1000, 1001, 1002, 1003, 1004,
 456                               1005, 1006, 1007, 1008};
 457   pids_list_t *pids_list_before = NULL;
 458   pids_list_t *pids_list_after = NULL;
 459   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_before); ++i)
 460     pids_list_add_pid(&pids_list_before, pids_array_before[i]);
 461
 462   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_after); ++i)
 463     pids_list_add_pid(&pids_list_after, pids_array_after[i]);
 464
 465   pids_list_t *new_pids = NULL;
 466   size_t new_pids_count = 0;
 467   pids_list_t *lost_pids = NULL;
 468   size_t lost_pids_count = 0;
 469
 470   /* check */
 471   int result = pids_list_diff(pids_list_before, pids_list_after, &new_pids,
 472                               &new_pids_count, &lost_pids, &lost_pids_count);
 473   EXPECT_EQ_INT(0, result);
 474   EXPECT_EQ_INT(0, lost_pids_count);
 475   EXPECT_EQ_INT(1, new_pids_count);
 476   EXPECT_EQ_INT(1008, new_pids->pid);
 477
 478   /* cleanup */
 479   pids_list_free(pids_list_before);
 480   pids_list_free(pids_list_after);
 481   pids_list_free(new_pids);
 482
 483   return 0;
 484 }
 485
 486 DEF_TEST(pids_list_diff__one_removed) {
 487   /* setup */
 488   pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004,
 489                                1005, 1006, 1007, 1008};
 490   pid_t pids_array_after[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
 491   pids_list_t *pids_list_before = NULL;
 492   pids_list_t *pids_list_after = NULL;
 493   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_before); ++i)
 494     pids_list_add_pid(&pids_list_before, pids_array_before[i]);
 495
 496   for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_after); ++i)
 497     pids_list_add_pid(&pids_list_after, pids_array_after[i]);
 498
 499   pids_list_t *new_pids = NULL;
 500   size_t new_pids_count = 0;
 501   pids_list_t *lost_pids = NULL;
 502   size_t lost_pids_count = 0;
 503
 504   /* check */
 505   int result = pids_list_diff(pids_list_before, pids_list_after, &new_pids,
 506                               &new_pids_count, &lost_pids, &lost_pids_count);
 507   EXPECT_EQ_INT(0, result);
 508   EXPECT_EQ_INT(1, lost_pids_count);
 509   EXPECT_EQ_INT(0, new_pids_count);
 510   EXPECT_EQ_INT(1008, lost_pids->pid);
 511
 512   /* cleanup */
 513   pids_list_free(pids_list_before);
 514   pids_list_free(pids_list_after);
 515   pids_list_free(lost_pids);
 516
 517   return 0;
 518 }
 519
 520 int main(void) {
 521   stub_procfs_teardown();
 522   RUN_TEST(initialize_proc_pids__on_nullptr);
 523   RUN_TEST(add_proc_pid__empty_list);
 524   RUN_TEST(add_proc_pid__non_empty_list);
 525   RUN_TEST(pids_list_to_array__non_empty_list);
 526   RUN_TEST(pids_list_add_pids_list__non_empty_lists);
 527   RUN_TEST(pids_list_add_pids_list__add_to_empty);
 528   RUN_TEST(get_pid_number__valid_dir);
 529   RUN_TEST(get_pid_number__invalid_dir_name);
 530   RUN_TEST(read_proc_name__valid_name);
 531   RUN_TEST(read_proc_name__invalid_name);
 532   RUN_TEST(fetch_pids_for_procs__one_proc_many_pid);
 533   RUN_TEST(fetch_pids_for_procs__many_proc_many_pid);
 534   RUN_TEST(pids_list_diff__all_changed);
 535   RUN_TEST(pids_list_diff__nothing_changed);
 536   RUN_TEST(pids_list_diff__one_added);
 537   RUN_TEST(pids_list_diff__one_removed);
 538   stub_procfs_teardown();
 539   END_TEST;
 540 }