Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/tools/tracing/rtla/tests/unit/unit_tests.c
170997 views
1
// SPDX-License-Identifier: GPL-2.0

2


3
#define _GNU_SOURCE

4
#include <check.h>

5
#include <stdio.h>

6
#include <stdlib.h>

7
#include <sched.h>

8
#include <limits.h>

9
#include <unistd.h>

10
#include <sys/sysinfo.h>

11


12
#include "../../src/utils.h"

13
int nr_cpus;

14


15
START_TEST(test_strtoi)

16
{

17
	int result;

18
	char buf[64];

19


20
	ck_assert_int_eq(strtoi("123", &result), 0);

21
	ck_assert_int_eq(result, 123);

22
	ck_assert_int_eq(strtoi(" -456", &result), 0);

23
	ck_assert_int_eq(result, -456);

24


25
	snprintf(buf, sizeof(buf), "%d", INT_MAX);

26
	ck_assert_int_eq(strtoi(buf, &result), 0);

27
	snprintf(buf, sizeof(buf), "%ld", (long)INT_MAX + 1);

28
	ck_assert_int_eq(strtoi(buf, &result), -1);

29


30
	ck_assert_int_eq(strtoi("", &result), -1);

31
	ck_assert_int_eq(strtoi("123abc", &result), -1);

32
	ck_assert_int_eq(strtoi("123 ", &result), -1);

33
}

34
END_TEST

35


36
START_TEST(test_parse_cpu_set)

37
{

38
	cpu_set_t set;

39


40
	nr_cpus = 8;

41
	ck_assert_int_eq(parse_cpu_set("0", &set), 0);

42
	ck_assert(CPU_ISSET(0, &set));

43
	ck_assert(!CPU_ISSET(1, &set));

44


45
	ck_assert_int_eq(parse_cpu_set("0,2", &set), 0);

46
	ck_assert(CPU_ISSET(0, &set));

47
	ck_assert(CPU_ISSET(2, &set));

48


49
	ck_assert_int_eq(parse_cpu_set("0-3", &set), 0);

50
	ck_assert(CPU_ISSET(0, &set));

51
	ck_assert(CPU_ISSET(1, &set));

52
	ck_assert(CPU_ISSET(2, &set));

53
	ck_assert(CPU_ISSET(3, &set));

54


55
	ck_assert_int_eq(parse_cpu_set("1-3,5", &set), 0);

56
	ck_assert(!CPU_ISSET(0, &set));

57
	ck_assert(CPU_ISSET(1, &set));

58
	ck_assert(CPU_ISSET(2, &set));

59
	ck_assert(CPU_ISSET(3, &set));

60
	ck_assert(!CPU_ISSET(4, &set));

61
	ck_assert(CPU_ISSET(5, &set));

62


63
	ck_assert_int_eq(parse_cpu_set("-1", &set), 1);

64
	ck_assert_int_eq(parse_cpu_set("abc", &set), 1);

65
	ck_assert_int_eq(parse_cpu_set("9999", &set), 1);

66
}

67
END_TEST

68


69
START_TEST(test_parse_prio)

70
{

71
	struct sched_attr attr;

72


73
	ck_assert_int_eq(parse_prio("f:50", &attr), 0);

74
	ck_assert_uint_eq(attr.sched_policy, SCHED_FIFO);

75
	ck_assert_uint_eq(attr.sched_priority, 50U);

76


77
	ck_assert_int_eq(parse_prio("r:30", &attr), 0);

78
	ck_assert_uint_eq(attr.sched_policy, SCHED_RR);

79


80
	ck_assert_int_eq(parse_prio("o:0", &attr), 0);

81
	ck_assert_uint_eq(attr.sched_policy, SCHED_OTHER);

82
	ck_assert_int_eq(attr.sched_nice, 0);

83


84
	ck_assert_int_eq(parse_prio("d:10ms:100ms", &attr), 0);

85
	ck_assert_uint_eq(attr.sched_policy, 6U);

86


87
	ck_assert_int_eq(parse_prio("f:999", &attr), -1);

88
	ck_assert_int_eq(parse_prio("o:-20", &attr), -1);

89
	ck_assert_int_eq(parse_prio("d:100ms:10ms", &attr), -1);

90
	ck_assert_int_eq(parse_prio("x:50", &attr), -1);

91
}

92
END_TEST

93


94
Suite *utils_suite(void)

95
{

96
	Suite *s = suite_create("utils");

97
	TCase *tc = tcase_create("core");

98


99
	tcase_add_test(tc, test_strtoi);

100
	tcase_add_test(tc, test_parse_cpu_set);

101
	tcase_add_test(tc, test_parse_prio);

102


103
	suite_add_tcase(s, tc);

104
	return s;

105
}

106


107
int main(void)

108
{

109
	int num_failed;

110
	SRunner *sr;

111


112
	sr = srunner_create(utils_suite());

113
	srunner_run_all(sr, CK_NORMAL);

114
	num_failed = srunner_ntests_failed(sr);

115


116
	srunner_free(sr);

117


118
	return (num_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;

119
}

120


121