2 #include "utils_proc_pids.c" /* sic */
5 /***************************************************************************
11 * pids_list_get_element
14 * Gets list element at index position. Assumes list was created by
15 * pids_list_add_pid function.
19 * `index' Position of desired element relative to given list pointer.
22 * Pointer to element at index position.
23 * NULL if index exceeds list's length.
25 pids_list_t *pids_list_get_element(pids_list_t *list, const size_t index) {
28 while (list != NULL && current != index) {
35 typedef struct stub_proc_pid {
40 static const char *proc_fs = "/tmp/procfs_stub";
47 * Prepares testing environment by creating temporary
48 * PID/comm file structure.
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.
57 * -1 on base dir creation error.
58 * -2 on comm file creation error.
59 * -3 on comm file write error.
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)
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);
74 FILE *fp = fopen(path, "w");
78 size_t slen = strlen(proc_pids_array[i].comm);
79 size_t wlen = fwrite(proc_pids_array[i].comm, sizeof(char), slen, fp);
90 * stub_procfs_teardown
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.
99 * system command result
101 int stub_procfs_teardown() {
103 sstrncpy(cmd, "rm -rf ", STATIC_ARRAY_SIZE(cmd));
104 strncat(cmd, proc_fs, STATIC_ARRAY_SIZE(cmd) - strlen(cmd) - 1);
108 /* Max PID value. More info:
109 * http://web.archive.org/web/20111209081734/http://research.cs.wisc.edu/condor/condorg/linux_scalability.html
111 #define MAX_PID 4194304
112 #define MAX_PID_STR "4194304"
114 /***************************************************************************
117 DEF_TEST(initialize_proc_pids__on_nullptr) {
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;
124 int result = initialize_proc_pids(procs_names_array, procs_names_array_size,
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);
131 free(proc_pids_array);
135 DEF_TEST(add_proc_pid__empty_list) {
137 proc_pids_t proc_pids_instance;
138 proc_pids_instance.pids = NULL;
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);
147 pids_list_free(proc_pids_instance.pids);
151 DEF_TEST(add_proc_pid__non_empty_list) {
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};
158 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i)
159 pids_list_add_pid(&proc_pids_instance.pids, pids[i]);
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);
167 pids_list_free(proc_pids_instance.pids);
171 DEF_TEST(pids_list_to_array__non_empty_list) {
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]);
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]);
185 pids_list_free(pids_list);
189 DEF_TEST(pids_list_add_pids_list__non_empty_lists) {
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;
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]);
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);
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]));
212 pids_list_free(pids_list_1);
213 pids_list_free(pids_list_2);
217 DEF_TEST(pids_list_add_pids_list__add_to_empty) {
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;
223 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array); ++i)
224 pids_list_add_pid(&pids_list_2, pids_array[i]);
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);
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]));
235 pids_list_free(pids_list_1);
236 pids_list_free(pids_list_2);
240 DEF_TEST(get_pid_number__valid_dir) {
243 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
248 int pid_conversion = get_pid_number(&d, &pid);
250 EXPECT_EQ_INT(0, pid_conversion);
251 EXPECT_EQ_INT(MAX_PID, pid);
257 DEF_TEST(get_pid_number__invalid_dir_name) {
260 sstrncpy(d.d_name, "invalid", STATIC_ARRAY_SIZE(d.d_name));
265 int pid_conversion = get_pid_number(&d, &pid);
267 EXPECT_EQ_INT(-1, pid_conversion);
268 EXPECT_EQ_INT(0, pid);
274 DEF_TEST(read_proc_name__valid_name) {
276 stub_proc_pid_t pp_stubs[] = {{"proc1", MAX_PID}};
277 stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
279 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
284 int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
286 EXPECT_EQ_INT(strlen(pp_stubs[0].comm), read_result);
287 EXPECT_EQ_STR(pp_stubs[0].comm, comm);
290 stub_procfs_teardown();
294 DEF_TEST(read_proc_name__invalid_name) {
297 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
302 int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
304 EXPECT_EQ_INT(-1, read_result);
310 DEF_TEST(fetch_pids_for_procs__one_proc_many_pid) {
312 const char *proc_names[] = {"proc1"};
313 stub_proc_pid_t pp_stubs[] = {{"proc1", 1007},
318 stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
319 proc_pids_t *output = NULL;
322 int result = fetch_pids_for_procs(proc_fs, proc_names,
323 STATIC_ARRAY_SIZE(proc_names), &output);
324 EXPECT_EQ_INT(0, result);
326 /* proc name check */
327 EXPECT_EQ_STR(proc_names[0], output[0].proccess_name);
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);
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);
339 for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i)
340 pids_list_free(output[i].pids);
342 stub_procfs_teardown();
346 DEF_TEST(fetch_pids_for_procs__many_proc_many_pid) {
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;
358 int result = fetch_pids_for_procs(proc_fs, proc_names,
359 STATIC_ARRAY_SIZE(proc_names), &output);
360 EXPECT_EQ_INT(0, result);
362 for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i) {
364 /* proc name check */
365 EXPECT_EQ_STR(proc_names[i], output[i].proccess_name);
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),
373 /* check if proc struct has no incorrect pids */
374 EXPECT_EQ_INT(pids_list_contains_pid(output[i].pids, pp_stubs[j].pid),
380 for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i)
381 pids_list_free(output[i].pids);
383 stub_procfs_teardown();
387 DEF_TEST(pids_list_diff__all_changed) {
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]);
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;
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);
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]));
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);
424 DEF_TEST(pids_list_diff__nothing_changed) {
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]);
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;
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);
447 pids_list_free(pids_list_before);
452 DEF_TEST(pids_list_diff__one_added) {
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]);
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]);
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;
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);
479 pids_list_free(pids_list_before);
480 pids_list_free(pids_list_after);
481 pids_list_free(new_pids);
486 DEF_TEST(pids_list_diff__one_removed) {
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]);
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]);
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;
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);
513 pids_list_free(pids_list_before);
514 pids_list_free(pids_list_after);
515 pids_list_free(lost_pids);
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();