2 #include "utils/proc_pids/proc_pids.c" /* sic */
5 /***************************************************************************
9 typedef struct stub_proc_pid {
14 static const char *proc_fs = "/tmp/procfs_stub";
21 * Prepares testing environment by creating temporary
22 * PID/comm file structure.
25 * `proc_pids_array' Array of stub_proc_pid_t structs. Represents
26 * which PIDs should hold given process name.
27 * `proc_pids_array_length' Element count of input array.
31 * -1 on base dir creation error.
32 * -2 on comm file creation error.
33 * -3 on comm file write error.
35 int stub_procfs_setup(const stub_proc_pid_t *proc_pids_array,
36 const size_t proc_pids_array_length) {
37 if (mkdir(proc_fs, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
41 for (size_t i = 0; i < proc_pids_array_length; ++i) {
42 memset(path, 0, sizeof(path));
43 snprintf(path, STATIC_ARRAY_SIZE(path), "%s/%d", proc_fs,
44 proc_pids_array[i].pid);
45 mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
46 strncat(path, "/comm", STATIC_ARRAY_SIZE(path) - strlen(path) - 1);
48 FILE *fp = fopen(path, "w");
52 size_t slen = strlen(proc_pids_array[i].comm);
53 size_t wlen = fwrite(proc_pids_array[i].comm, sizeof(char), slen, fp);
64 * stub_procfs_teardown
67 * Clears testing environment: removes stub proc files.
68 * NOTE - This function could be implemented by usage of nftw, but this
69 * would require #define _XOPEN_SOURCE 500, which
70 * messes up intel_rdt includes.
73 * system command result
75 int stub_procfs_teardown() {
77 sstrncpy(cmd, "rm -rf ", STATIC_ARRAY_SIZE(cmd));
78 strncat(cmd, proc_fs, STATIC_ARRAY_SIZE(cmd) - strlen(cmd) - 1);
82 /* Max PID value. More info:
83 * http://web.archive.org/web/20111209081734/http://research.cs.wisc.edu/condor/condorg/linux_scalability.html
85 #define MAX_PID 4194304
86 #define MAX_PID_STR "4194304"
88 /***************************************************************************
91 DEF_TEST(proc_pids_init__on_nullptr) {
93 const char *procs_names_array[] = {"proc1", "proc2", "proc3"};
94 const size_t procs_names_array_size = STATIC_ARRAY_SIZE(procs_names_array);
95 proc_pids_t **proc_pids_array = NULL;
98 int result = proc_pids_init(procs_names_array, procs_names_array_size,
100 EXPECT_EQ_INT(0, result);
101 for (size_t i = 0; i < procs_names_array_size; ++i)
102 EXPECT_EQ_STR(procs_names_array[i], proc_pids_array[i]->process_name);
105 proc_pids_free(proc_pids_array, procs_names_array_size);
109 DEF_TEST(pid_list_add_pid__empty_list) {
111 pids_list_t *proc_pids_instance = calloc(1, sizeof(*proc_pids_instance));
115 pids_list_add_pid(proc_pids_instance, pid);
116 EXPECT_EQ_INT(pid, proc_pids_instance->pids[0]);
119 pids_list_free(proc_pids_instance);
123 DEF_TEST(pid_list_add_pid__non_empty_list) {
125 pids_list_t *proc_pids_instance = calloc(1, sizeof(*proc_pids_instance));
126 pid_t pids[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
129 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i)
130 pids_list_add_pid(proc_pids_instance, pids[i]);
132 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids); ++i) {
133 EXPECT_EQ_INT(pids[i], proc_pids_instance->pids[i]);
137 pids_list_free(proc_pids_instance);
141 DEF_TEST(pids_list_add_pids_list__non_empty_lists) {
143 pid_t pids_array_1[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
144 pid_t pids_array_2[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
145 pids_list_t *pids_list_1 = calloc(1, sizeof(*pids_list_1));
146 pids_list_t *pids_list_2 = calloc(1, sizeof(*pids_list_2));
147 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_1); ++i) {
148 pids_list_add_pid(pids_list_1, pids_array_1[i]);
149 pids_list_add_pid(pids_list_2, pids_array_2[i]);
153 int result = pids_list_add_list(pids_list_1, pids_list_2);
154 EXPECT_EQ_INT(0, result);
155 EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_2) +
156 STATIC_ARRAY_SIZE(pids_array_1),
159 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_1); ++i) {
160 EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array_1[i]));
161 EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array_2[i]));
165 pids_list_free(pids_list_1);
166 pids_list_free(pids_list_2);
170 DEF_TEST(pids_list_add_pids_list__add_to_empty) {
172 pid_t pids_array[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
173 pids_list_t *pids_list_1 = calloc(1, sizeof(*pids_list_1));
174 pids_list_t *pids_list_2 = calloc(1, sizeof(*pids_list_2));
175 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array); ++i)
176 pids_list_add_pid(pids_list_2, pids_array[i]);
179 int result = pids_list_add_list(pids_list_1, pids_list_2);
180 EXPECT_EQ_INT(0, result);
181 EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array), pids_list_1->size);
183 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array); ++i)
184 EXPECT_EQ_INT(1, pids_list_contains_pid(pids_list_1, pids_array[i]));
187 pids_list_free(pids_list_1);
188 pids_list_free(pids_list_2);
192 DEF_TEST(get_pid_number__valid_dir) {
195 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
200 int pid_conversion = get_pid_number(&d, &pid);
202 EXPECT_EQ_INT(0, pid_conversion);
203 EXPECT_EQ_INT(MAX_PID, pid);
209 DEF_TEST(get_pid_number__invalid_dir_name) {
212 sstrncpy(d.d_name, "invalid", STATIC_ARRAY_SIZE(d.d_name));
217 int pid_conversion = get_pid_number(&d, &pid);
219 EXPECT_EQ_INT(-1, pid_conversion);
220 EXPECT_EQ_INT(0, pid);
226 DEF_TEST(read_proc_name__valid_name) {
228 stub_proc_pid_t pp_stubs[] = {{"proc1", MAX_PID}};
229 stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
231 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
236 int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
238 EXPECT_EQ_INT(strlen(pp_stubs[0].comm), read_result);
239 EXPECT_EQ_STR(pp_stubs[0].comm, comm);
242 stub_procfs_teardown();
246 DEF_TEST(read_proc_name__invalid_name) {
249 sstrncpy(d.d_name, MAX_PID_STR, STATIC_ARRAY_SIZE(d.d_name));
254 int read_result = read_proc_name(proc_fs, &d, comm, STATIC_ARRAY_SIZE(comm));
256 EXPECT_EQ_INT(-1, read_result);
262 DEF_TEST(proc_pids_update__one_proc_many_pid) {
264 const char *proc_names[] = {"proc1"};
265 stub_proc_pid_t pp_stubs[] = {{"proc1", 1007},
270 proc_pids_t **proc_pids = NULL;
272 stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
275 proc_pids_init(proc_names, STATIC_ARRAY_SIZE(proc_names), &proc_pids);
276 EXPECT_EQ_INT(0, result);
279 result = proc_pids_update(proc_fs, proc_pids, STATIC_ARRAY_SIZE(proc_names));
280 EXPECT_EQ_INT(0, result);
282 /* proc name check */
283 EXPECT_EQ_STR(proc_names[0], proc_pids[0]->process_name);
285 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pp_stubs); ++i) {
286 if (0 == strcmp(pp_stubs[i].comm, proc_names[0]))
287 /* check if proc struct has correct pids */
288 EXPECT_EQ_INT(pids_list_contains_pid(proc_pids[0]->curr, pp_stubs[i].pid),
291 /* check if proc struct has no incorrect pids */
292 EXPECT_EQ_INT(pids_list_contains_pid(proc_pids[0]->curr, pp_stubs[i].pid),
297 proc_pids_free(proc_pids, STATIC_ARRAY_SIZE(proc_names));
298 stub_procfs_teardown();
302 DEF_TEST(proc_pids_update__many_proc_many_pid) {
304 const char *proc_names[] = {"proc1", "proc2", "proc3"};
305 stub_proc_pid_t pp_stubs[] = {
306 {"proc1", 1007}, {"proc1", 1008}, {"proc1", 1009}, {"proc2", 2007},
307 {"proc2", 2008}, {"proc2", 2009}, {"proc3", 3007}, {"proc3", 3008},
308 {"proc3", 3009}, {"proc4", 4007}, {"proc4", 4008}, {"proc4", 4009},
309 {"proc5", 5007}, {"proc5", 5008}, {"proc5", 5009}};
310 proc_pids_t **proc_pids = NULL;
312 stub_procfs_setup(pp_stubs, STATIC_ARRAY_SIZE(pp_stubs));
315 proc_pids_init(proc_names, STATIC_ARRAY_SIZE(proc_names), &proc_pids);
316 EXPECT_EQ_INT(0, result);
319 result = proc_pids_update(proc_fs, proc_pids, STATIC_ARRAY_SIZE(proc_names));
320 EXPECT_EQ_INT(0, result);
322 for (size_t i = 0; i < STATIC_ARRAY_SIZE(proc_names); ++i) {
324 /* proc name check */
325 EXPECT_EQ_STR(proc_names[i], proc_pids[i]->process_name);
327 for (size_t j = 0; j < STATIC_ARRAY_SIZE(pp_stubs); ++j) {
328 if (0 == strcmp(pp_stubs[j].comm, proc_names[i]))
329 /* check if proc struct has correct pids */
331 pids_list_contains_pid(proc_pids[i]->curr, pp_stubs[j].pid), 1);
333 /* check if proc struct has no incorrect pids */
335 pids_list_contains_pid(proc_pids[i]->curr, pp_stubs[j].pid), 0);
340 proc_pids_free(proc_pids, STATIC_ARRAY_SIZE(proc_names));
341 stub_procfs_teardown();
345 DEF_TEST(pids_list_diff__all_changed) {
347 pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
348 pid_t pids_array_after[] = {2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007};
349 proc_pids_t proc_pids;
353 prev.pids = pids_array_before;
354 prev.size = STATIC_ARRAY_SIZE(pids_array_before);
355 prev.allocated = prev.size;
356 curr.pids = pids_array_after;
357 curr.size = STATIC_ARRAY_SIZE(pids_array_after);
358 curr.allocated = curr.size;
359 proc_pids.curr = &curr;
360 proc_pids.prev = &prev;
362 pids_list_t *new_pids = calloc(1, sizeof(*new_pids));
363 pids_list_t *lost_pids = calloc(1, sizeof(*lost_pids));
366 int result = pids_list_diff(&proc_pids, new_pids, lost_pids);
367 EXPECT_EQ_INT(0, result);
368 EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_before), lost_pids->size);
369 EXPECT_EQ_INT(STATIC_ARRAY_SIZE(pids_array_after), new_pids->size);
371 for (size_t i = 0; i < STATIC_ARRAY_SIZE(pids_array_before); ++i) {
372 EXPECT_EQ_INT(1, pids_list_contains_pid(new_pids, pids_array_after[i]));
373 EXPECT_EQ_INT(1, pids_list_contains_pid(lost_pids, pids_array_before[i]));
377 pids_list_free(new_pids);
378 pids_list_free(lost_pids);
383 DEF_TEST(pids_list_diff__nothing_changed) {
385 pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
386 proc_pids_t proc_pids;
390 prev.pids = pids_array_before;
391 prev.size = STATIC_ARRAY_SIZE(pids_array_before);
392 prev.allocated = prev.size;
393 curr.pids = pids_array_before;
394 curr.size = STATIC_ARRAY_SIZE(pids_array_before);
395 curr.allocated = curr.size;
396 proc_pids.curr = &curr;
397 proc_pids.prev = &prev;
399 pids_list_t *new_pids = calloc(1, sizeof(*new_pids));
400 pids_list_t *lost_pids = calloc(1, sizeof(*lost_pids));
403 int result = pids_list_diff(&proc_pids, new_pids, lost_pids);
404 EXPECT_EQ_INT(0, result);
405 EXPECT_EQ_INT(0, lost_pids->size);
406 EXPECT_EQ_INT(0, new_pids->size);
409 pids_list_free(lost_pids);
410 pids_list_free(new_pids);
415 DEF_TEST(pids_list_diff__one_added) {
417 pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
418 pid_t pids_array_after[] = {1000, 1001, 1002, 1003, 1004,
419 1005, 1006, 1007, 1008};
420 proc_pids_t proc_pids;
424 prev.pids = pids_array_before;
425 prev.size = STATIC_ARRAY_SIZE(pids_array_before);
426 prev.allocated = prev.size;
427 curr.pids = pids_array_after;
428 curr.size = STATIC_ARRAY_SIZE(pids_array_after);
429 curr.allocated = curr.size;
430 proc_pids.curr = &curr;
431 proc_pids.prev = &prev;
433 pids_list_t *new_pids = calloc(1, sizeof(*new_pids));
434 pids_list_t *lost_pids = calloc(1, sizeof(*lost_pids));
437 int result = pids_list_diff(&proc_pids, new_pids, lost_pids);
438 EXPECT_EQ_INT(0, result);
439 EXPECT_EQ_INT(0, lost_pids->size);
440 EXPECT_EQ_INT(1, new_pids->size);
441 EXPECT_EQ_INT(1008, new_pids->pids[0]);
444 pids_list_free(lost_pids);
445 pids_list_free(new_pids);
450 DEF_TEST(pids_list_diff__one_removed) {
452 pid_t pids_array_before[] = {1000, 1001, 1002, 1003, 1004,
453 1005, 1006, 1007, 1008};
454 pid_t pids_array_after[] = {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007};
456 proc_pids_t proc_pids;
460 prev.pids = pids_array_before;
461 prev.size = STATIC_ARRAY_SIZE(pids_array_before);
462 prev.allocated = prev.size;
463 curr.pids = pids_array_after;
464 curr.size = STATIC_ARRAY_SIZE(pids_array_after);
465 curr.allocated = curr.size;
466 proc_pids.curr = &curr;
467 proc_pids.prev = &prev;
469 pids_list_t *new_pids = calloc(1, sizeof(*new_pids));
470 pids_list_t *lost_pids = calloc(1, sizeof(*lost_pids));
473 int result = pids_list_diff(&proc_pids, new_pids, lost_pids);
474 EXPECT_EQ_INT(0, result);
475 EXPECT_EQ_INT(0, new_pids->size);
476 EXPECT_EQ_INT(1, lost_pids->size);
477 EXPECT_EQ_INT(1008, lost_pids->pids[0]);
480 pids_list_free(lost_pids);
481 pids_list_free(new_pids);
487 stub_procfs_teardown();
488 RUN_TEST(proc_pids_init__on_nullptr);
489 RUN_TEST(pid_list_add_pid__empty_list);
490 RUN_TEST(pid_list_add_pid__non_empty_list);
491 RUN_TEST(pids_list_add_pids_list__non_empty_lists);
492 RUN_TEST(pids_list_add_pids_list__add_to_empty);
493 RUN_TEST(get_pid_number__valid_dir);
494 RUN_TEST(get_pid_number__invalid_dir_name);
495 RUN_TEST(read_proc_name__valid_name);
496 RUN_TEST(read_proc_name__invalid_name);
497 RUN_TEST(proc_pids_update__one_proc_many_pid);
498 RUN_TEST(proc_pids_update__many_proc_many_pid);
499 RUN_TEST(pids_list_diff__all_changed);
500 RUN_TEST(pids_list_diff__nothing_changed);
501 RUN_TEST(pids_list_diff__one_added);
502 RUN_TEST(pids_list_diff__one_removed);
503 stub_procfs_teardown();