projects/linux·blob master · refs

224 lines · 6.2 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit test for the generic kernel FIFO implementation.
4 *
5 * Copyright (C) 2024 Diego Vieira <[email protected]>
6 */
7#include <kunit/test.h>
8
9#include <linux/kfifo.h>
10
11#define KFIFO_SIZE 32
12#define N_ELEMENTS 5
13
14static void kfifo_test_reset_should_clear_the_fifo(struct kunit *test)
15{
16 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
17
18 kfifo_put(&my_fifo, 1);
19 kfifo_put(&my_fifo, 2);
20 kfifo_put(&my_fifo, 3);
21 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 3);
22
23 kfifo_reset(&my_fifo);
24
25 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 0);
26 KUNIT_EXPECT_TRUE(test, kfifo_is_empty(&my_fifo));
27}
28
29static void kfifo_test_define_should_define_an_empty_fifo(struct kunit *test)
30{
31 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
32
33 KUNIT_EXPECT_TRUE(test, kfifo_initialized(&my_fifo));
34 KUNIT_EXPECT_TRUE(test, kfifo_is_empty(&my_fifo));
35 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 0);
36}
37
38static void kfifo_test_len_should_ret_n_of_stored_elements(struct kunit *test)
39{
40 u8 buffer1[N_ELEMENTS];
41
42 for (int i = 0; i < N_ELEMENTS; i++)
43 buffer1[i] = i + 1;
44
45 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
46
47 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 0);
48
49 kfifo_in(&my_fifo, buffer1, N_ELEMENTS);
50 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), N_ELEMENTS);
51
52 kfifo_in(&my_fifo, buffer1, N_ELEMENTS);
53 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), N_ELEMENTS * 2);
54
55 kfifo_reset(&my_fifo);
56 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 0);
57}
58
59static void kfifo_test_put_should_insert_and_get_should_pop(struct kunit *test)
60{
61 u8 out_data = 0;
62 int processed_elements;
63 u8 elements[] = { 3, 5, 11 };
64
65 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
66
67 // If the fifo is empty, get returns 0
68 processed_elements = kfifo_get(&my_fifo, &out_data);
69 KUNIT_EXPECT_EQ(test, processed_elements, 0);
70 KUNIT_EXPECT_EQ(test, out_data, 0);
71
72 for (int i = 0; i < 3; i++)
73 kfifo_put(&my_fifo, elements[i]);
74
75 for (int i = 0; i < 3; i++) {
76 processed_elements = kfifo_get(&my_fifo, &out_data);
77 KUNIT_EXPECT_EQ(test, processed_elements, 1);
78 KUNIT_EXPECT_EQ(test, out_data, elements[i]);
79 }
80}
81
82static void kfifo_test_in_should_insert_multiple_elements(struct kunit *test)
83{
84 u8 in_buffer[] = { 11, 25, 65 };
85 u8 out_data;
86 int processed_elements;
87
88 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
89
90 kfifo_in(&my_fifo, in_buffer, 3);
91
92 for (int i = 0; i < 3; i++) {
93 processed_elements = kfifo_get(&my_fifo, &out_data);
94 KUNIT_EXPECT_EQ(test, processed_elements, 1);
95 KUNIT_EXPECT_EQ(test, out_data, in_buffer[i]);
96 }
97}
98
99static void kfifo_test_out_should_pop_multiple_elements(struct kunit *test)
100{
101 u8 in_buffer[] = { 11, 25, 65 };
102 u8 out_buffer[3];
103 int copied_elements;
104
105 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
106
107 for (int i = 0; i < 3; i++)
108 kfifo_put(&my_fifo, in_buffer[i]);
109
110 copied_elements = kfifo_out(&my_fifo, out_buffer, 3);
111 KUNIT_EXPECT_EQ(test, copied_elements, 3);
112
113 for (int i = 0; i < 3; i++)
114 KUNIT_EXPECT_EQ(test, out_buffer[i], in_buffer[i]);
115 KUNIT_EXPECT_TRUE(test, kfifo_is_empty(&my_fifo));
116}
117
118static void kfifo_test_dec_init_should_define_an_empty_fifo(struct kunit *test)
119{
120 DECLARE_KFIFO(my_fifo, u8, KFIFO_SIZE);
121
122 INIT_KFIFO(my_fifo);
123
124 // my_fifo is a struct with an inplace buffer
125 KUNIT_EXPECT_FALSE(test, __is_kfifo_ptr(&my_fifo));
126
127 KUNIT_EXPECT_TRUE(test, kfifo_initialized(&my_fifo));
128}
129
130static void kfifo_test_define_should_equal_declare_init(struct kunit *test)
131{
132 // declare a variable my_fifo of type struct kfifo of u8
133 DECLARE_KFIFO(my_fifo1, u8, KFIFO_SIZE);
134 // initialize the my_fifo variable
135 INIT_KFIFO(my_fifo1);
136
137 // DEFINE_KFIFO declares the variable with the initial value
138 // essentially the same as calling DECLARE_KFIFO and INIT_KFIFO
139 DEFINE_KFIFO(my_fifo2, u8, KFIFO_SIZE);
140
141 // my_fifo1 and my_fifo2 have the same size
142 KUNIT_EXPECT_EQ(test, sizeof(my_fifo1), sizeof(my_fifo2));
143 KUNIT_EXPECT_EQ(test, kfifo_initialized(&my_fifo1),
144 kfifo_initialized(&my_fifo2));
145 KUNIT_EXPECT_EQ(test, kfifo_is_empty(&my_fifo1),
146 kfifo_is_empty(&my_fifo2));
147}
148
149static void kfifo_test_alloc_should_initiliaze_a_ptr_fifo(struct kunit *test)
150{
151 int ret;
152 DECLARE_KFIFO_PTR(my_fifo, u8);
153
154 INIT_KFIFO(my_fifo);
155
156 // kfifo_initialized returns false signaling the buffer pointer is NULL
157 KUNIT_EXPECT_FALSE(test, kfifo_initialized(&my_fifo));
158
159 // kfifo_alloc allocates the buffer
160 ret = kfifo_alloc(&my_fifo, KFIFO_SIZE, GFP_KERNEL);
161 KUNIT_EXPECT_EQ_MSG(test, ret, 0, "Memory allocation should succeed");
162 KUNIT_EXPECT_TRUE(test, kfifo_initialized(&my_fifo));
163
164 // kfifo_free frees the buffer
165 kfifo_free(&my_fifo);
166}
167
168static void kfifo_test_peek_should_not_remove_elements(struct kunit *test)
169{
170 u8 out_data;
171 int processed_elements;
172
173 DEFINE_KFIFO(my_fifo, u8, KFIFO_SIZE);
174
175 // If the fifo is empty, peek returns 0
176 processed_elements = kfifo_peek(&my_fifo, &out_data);
177 KUNIT_EXPECT_EQ(test, processed_elements, 0);
178
179 kfifo_put(&my_fifo, 3);
180 kfifo_put(&my_fifo, 5);
181 kfifo_put(&my_fifo, 11);
182
183 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 3);
184
185 processed_elements = kfifo_peek(&my_fifo, &out_data);
186 KUNIT_EXPECT_EQ(test, processed_elements, 1);
187 KUNIT_EXPECT_EQ(test, out_data, 3);
188
189 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 3);
190
191 // Using peek doesn't remove the element
192 // so the read element and the fifo length
193 // remains the same
194 processed_elements = kfifo_peek(&my_fifo, &out_data);
195 KUNIT_EXPECT_EQ(test, processed_elements, 1);
196 KUNIT_EXPECT_EQ(test, out_data, 3);
197
198 KUNIT_EXPECT_EQ(test, kfifo_len(&my_fifo), 3);
199}
200
201static struct kunit_case kfifo_test_cases[] = {
202 KUNIT_CASE(kfifo_test_reset_should_clear_the_fifo),
203 KUNIT_CASE(kfifo_test_define_should_define_an_empty_fifo),
204 KUNIT_CASE(kfifo_test_len_should_ret_n_of_stored_elements),
205 KUNIT_CASE(kfifo_test_put_should_insert_and_get_should_pop),
206 KUNIT_CASE(kfifo_test_in_should_insert_multiple_elements),
207 KUNIT_CASE(kfifo_test_out_should_pop_multiple_elements),
208 KUNIT_CASE(kfifo_test_dec_init_should_define_an_empty_fifo),
209 KUNIT_CASE(kfifo_test_define_should_equal_declare_init),
210 KUNIT_CASE(kfifo_test_alloc_should_initiliaze_a_ptr_fifo),
211 KUNIT_CASE(kfifo_test_peek_should_not_remove_elements),
212 {},
213};
214
215static struct kunit_suite kfifo_test_module = {
216 .name = "kfifo",
217 .test_cases = kfifo_test_cases,
218};
219
220kunit_test_suites(&kfifo_test_module);
221
222MODULE_LICENSE("GPL");
223MODULE_AUTHOR("Diego Vieira <[email protected]>");
224MODULE_DESCRIPTION("KUnit test for the kernel FIFO");