1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2020-2022, Intel Corporation */
/*
* threshold.c -- rpma_log_[get/set]_threshold unit tests
*/
#include <stdlib.h>
#include "cmocka_headers.h"
#include "log_internal.h"
#include "log_default.h"
#include "librpma.h"
#define INVALID_THRESHOLD_MOCK ((enum rpma_log_threshold)(-1))
#define INVALID_LEVEL_MOCK (-2)
/*
* set_threshold__threshold_invalid -- use an invalid threshold
*/
void
set_threshold__threshold_invalid(void **unused)
{
int ret = rpma_log_set_threshold(INVALID_THRESHOLD_MOCK,
RPMA_LOG_DISABLED);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* set_threshold__level_invalid -- use an invalid level
*/
void
set_threshold__level_invalid(void **unused)
{
int ret = rpma_log_set_threshold(RPMA_LOG_THRESHOLD,
INVALID_LEVEL_MOCK);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* set_threshold__threshold_level_invalid -- use an invalid threshold and level
*/
void
set_threshold__threshold_level_invalid(void **unused)
{
int ret = rpma_log_set_threshold(INVALID_THRESHOLD_MOCK,
INVALID_LEVEL_MOCK);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* get_threshold__threshold_invalid -- use an invalid threshold
*/
void
get_threshold__threshold_invalid(void **unused)
{
enum rpma_log_level level;
int ret = rpma_log_get_threshold(INVALID_THRESHOLD_MOCK, &level);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* get_threshold__level_invalid -- NULL level is invalid
*/
void
get_threshold__level_invalid(void **unused)
{
int ret = rpma_log_get_threshold(RPMA_LOG_THRESHOLD, NULL);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* get_threshold__threshold_level_invalid -- use an invalid threshold and level
*/
void
get_threshold__threshold_level_invalid(void **unused)
{
int ret = rpma_log_get_threshold(INVALID_THRESHOLD_MOCK, NULL);
assert_int_equal(ret, RPMA_E_INVAL);
}
/*
* threshold_lifecycle -- happy day scenario
*/
void
threshold_lifecycle(void **unused)
{
enum rpma_log_level level;
for (int i = RPMA_LOG_THRESHOLD; i <= RPMA_LOG_THRESHOLD_AUX; i++) {
for (int j = RPMA_LOG_DISABLED; j <= RPMA_LOG_LEVEL_DEBUG;
j++) {
int ret;
do {
ret = rpma_log_set_threshold(
(enum rpma_log_threshold)i, j);
} while (ret == RPMA_E_AGAIN);
assert_int_equal(ret, 0);
ret = rpma_log_get_threshold(
(enum rpma_log_threshold)i, &level);
assert_int_equal(level, j);
assert_int_equal(ret, 0);
}
}
}
int
main(int argc, char *argv[])
{
const struct CMUnitTest tests[] = {
/* rpma_log_set_threshold() unit tests */
cmocka_unit_test(set_threshold__threshold_invalid),
cmocka_unit_test(set_threshold__level_invalid),
cmocka_unit_test(set_threshold__threshold_level_invalid),
/* rpma_log_get_threshold() unit tests */
cmocka_unit_test(get_threshold__threshold_invalid),
cmocka_unit_test(get_threshold__level_invalid),
cmocka_unit_test(get_threshold__threshold_level_invalid),
/* rpma_log_[set/get]_threshold() success test */
cmocka_unit_test(threshold_lifecycle),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
|
