1 | // SPDX-License-Identifier: BSD-3-Clause |
2 | /* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries. |
3 | * Microchip VCAP API kunit test suite |
4 | */ |
5 | |
6 | #include <kunit/test.h> |
7 | #include "vcap_api.h" |
8 | #include "vcap_api_client.h" |
9 | #include "vcap_api_debugfs.h" |
10 | #include "vcap_model_kunit.h" |
11 | |
12 | /* First we have the test infrastructure that emulates the platform |
13 | * implementation |
14 | */ |
15 | #define TEST_BUF_CNT 100 |
16 | #define TEST_BUF_SZ 350 |
17 | #define STREAMWSIZE 64 |
18 | |
19 | static u32 test_updateaddr[STREAMWSIZE] = {}; |
20 | static int test_updateaddridx; |
21 | static int test_cache_erase_count; |
22 | static u32 test_init_start; |
23 | static u32 test_init_count; |
24 | static u32 test_hw_counter_id; |
25 | static struct vcap_cache_data test_hw_cache; |
26 | static struct net_device test_netdev = {}; |
27 | static int test_move_addr; |
28 | static int test_move_offset; |
29 | static int test_move_count; |
30 | static char test_pr_buffer[TEST_BUF_CNT][TEST_BUF_SZ]; |
31 | static int test_pr_bufferidx; |
32 | static int test_pr_idx; |
33 | |
34 | /* Callback used by the VCAP API */ |
35 | static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev, |
36 | struct vcap_admin *admin, |
37 | struct vcap_rule *rule, |
38 | struct vcap_keyset_list *kslist, |
39 | u16 l3_proto) |
40 | { |
41 | int idx; |
42 | |
43 | if (kslist->cnt > 0) { |
44 | switch (admin->vtype) { |
45 | case VCAP_TYPE_IS0: |
46 | for (idx = 0; idx < kslist->cnt; idx++) { |
47 | if (kslist->keysets[idx] == VCAP_KFS_ETAG) |
48 | return kslist->keysets[idx]; |
49 | if (kslist->keysets[idx] == |
50 | VCAP_KFS_PURE_5TUPLE_IP4) |
51 | return kslist->keysets[idx]; |
52 | if (kslist->keysets[idx] == |
53 | VCAP_KFS_NORMAL_5TUPLE_IP4) |
54 | return kslist->keysets[idx]; |
55 | if (kslist->keysets[idx] == |
56 | VCAP_KFS_NORMAL_7TUPLE) |
57 | return kslist->keysets[idx]; |
58 | } |
59 | break; |
60 | case VCAP_TYPE_IS2: |
61 | for (idx = 0; idx < kslist->cnt; idx++) { |
62 | if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE) |
63 | return kslist->keysets[idx]; |
64 | if (kslist->keysets[idx] == VCAP_KFS_ARP) |
65 | return kslist->keysets[idx]; |
66 | if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE) |
67 | return kslist->keysets[idx]; |
68 | } |
69 | break; |
70 | default: |
71 | pr_info("%s:%d: no validation for VCAP %d\n" , |
72 | __func__, __LINE__, admin->vtype); |
73 | break; |
74 | } |
75 | } |
76 | return -EINVAL; |
77 | } |
78 | |
79 | /* Callback used by the VCAP API */ |
80 | static void test_add_def_fields(struct net_device *ndev, |
81 | struct vcap_admin *admin, |
82 | struct vcap_rule *rule) |
83 | { |
84 | if (admin->vinst == 0 || admin->vinst == 2) |
85 | vcap_rule_add_key_bit(rule, key: VCAP_KF_LOOKUP_FIRST_IS, |
86 | val: VCAP_BIT_1); |
87 | else |
88 | vcap_rule_add_key_bit(rule, key: VCAP_KF_LOOKUP_FIRST_IS, |
89 | val: VCAP_BIT_0); |
90 | } |
91 | |
92 | /* Callback used by the VCAP API */ |
93 | static void test_cache_erase(struct vcap_admin *admin) |
94 | { |
95 | if (test_cache_erase_count) { |
96 | memset(admin->cache.keystream, 0, test_cache_erase_count); |
97 | memset(admin->cache.maskstream, 0, test_cache_erase_count); |
98 | memset(admin->cache.actionstream, 0, test_cache_erase_count); |
99 | test_cache_erase_count = 0; |
100 | } |
101 | } |
102 | |
103 | /* Callback used by the VCAP API */ |
104 | static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin, |
105 | u32 start, u32 count) |
106 | { |
107 | test_init_start = start; |
108 | test_init_count = count; |
109 | } |
110 | |
111 | /* Callback used by the VCAP API */ |
112 | static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin, |
113 | enum vcap_selection sel, u32 start, u32 count) |
114 | { |
115 | u32 *keystr, *mskstr, *actstr; |
116 | int idx; |
117 | |
118 | pr_debug("%s:%d: %d %d\n" , __func__, __LINE__, start, count); |
119 | switch (sel) { |
120 | case VCAP_SEL_ENTRY: |
121 | keystr = &admin->cache.keystream[start]; |
122 | mskstr = &admin->cache.maskstream[start]; |
123 | for (idx = 0; idx < count; ++idx) { |
124 | pr_debug("%s:%d: keydata[%02d]: 0x%08x\n" , __func__, |
125 | __LINE__, start + idx, keystr[idx]); |
126 | } |
127 | for (idx = 0; idx < count; ++idx) { |
128 | /* Invert the mask before decoding starts */ |
129 | mskstr[idx] = ~mskstr[idx]; |
130 | pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n" , __func__, |
131 | __LINE__, start + idx, mskstr[idx]); |
132 | } |
133 | break; |
134 | case VCAP_SEL_ACTION: |
135 | actstr = &admin->cache.actionstream[start]; |
136 | for (idx = 0; idx < count; ++idx) { |
137 | pr_debug("%s:%d: actdata[%02d]: 0x%08x\n" , __func__, |
138 | __LINE__, start + idx, actstr[idx]); |
139 | } |
140 | break; |
141 | case VCAP_SEL_COUNTER: |
142 | pr_debug("%s:%d\n" , __func__, __LINE__); |
143 | test_hw_counter_id = start; |
144 | admin->cache.counter = test_hw_cache.counter; |
145 | admin->cache.sticky = test_hw_cache.sticky; |
146 | break; |
147 | case VCAP_SEL_ALL: |
148 | pr_debug("%s:%d\n" , __func__, __LINE__); |
149 | break; |
150 | } |
151 | } |
152 | |
153 | /* Callback used by the VCAP API */ |
154 | static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin, |
155 | enum vcap_selection sel, u32 start, u32 count) |
156 | { |
157 | u32 *keystr, *mskstr, *actstr; |
158 | int idx; |
159 | |
160 | switch (sel) { |
161 | case VCAP_SEL_ENTRY: |
162 | keystr = &admin->cache.keystream[start]; |
163 | mskstr = &admin->cache.maskstream[start]; |
164 | for (idx = 0; idx < count; ++idx) { |
165 | pr_debug("%s:%d: keydata[%02d]: 0x%08x\n" , __func__, |
166 | __LINE__, start + idx, keystr[idx]); |
167 | } |
168 | for (idx = 0; idx < count; ++idx) { |
169 | /* Invert the mask before encoding starts */ |
170 | mskstr[idx] = ~mskstr[idx]; |
171 | pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n" , __func__, |
172 | __LINE__, start + idx, mskstr[idx]); |
173 | } |
174 | break; |
175 | case VCAP_SEL_ACTION: |
176 | actstr = &admin->cache.actionstream[start]; |
177 | for (idx = 0; idx < count; ++idx) { |
178 | pr_debug("%s:%d: actdata[%02d]: 0x%08x\n" , __func__, |
179 | __LINE__, start + idx, actstr[idx]); |
180 | } |
181 | break; |
182 | case VCAP_SEL_COUNTER: |
183 | pr_debug("%s:%d\n" , __func__, __LINE__); |
184 | test_hw_counter_id = start; |
185 | test_hw_cache.counter = admin->cache.counter; |
186 | test_hw_cache.sticky = admin->cache.sticky; |
187 | break; |
188 | case VCAP_SEL_ALL: |
189 | pr_err("%s:%d: cannot write all streams at once\n" , |
190 | __func__, __LINE__); |
191 | break; |
192 | } |
193 | } |
194 | |
195 | /* Callback used by the VCAP API */ |
196 | static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin, |
197 | enum vcap_command cmd, |
198 | enum vcap_selection sel, u32 addr) |
199 | { |
200 | if (test_updateaddridx < ARRAY_SIZE(test_updateaddr)) |
201 | test_updateaddr[test_updateaddridx] = addr; |
202 | else |
203 | pr_err("%s:%d: overflow: %d\n" , __func__, __LINE__, |
204 | test_updateaddridx); |
205 | test_updateaddridx++; |
206 | } |
207 | |
208 | static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin, |
209 | u32 addr, int offset, int count) |
210 | { |
211 | test_move_addr = addr; |
212 | test_move_offset = offset; |
213 | test_move_count = count; |
214 | } |
215 | |
216 | /* Provide port information via a callback interface */ |
217 | static int vcap_test_port_info(struct net_device *ndev, |
218 | struct vcap_admin *admin, |
219 | struct vcap_output_print *out) |
220 | { |
221 | return 0; |
222 | } |
223 | |
224 | static struct vcap_operations test_callbacks = { |
225 | .validate_keyset = test_val_keyset, |
226 | .add_default_fields = test_add_def_fields, |
227 | .cache_erase = test_cache_erase, |
228 | .cache_write = test_cache_write, |
229 | .cache_read = test_cache_read, |
230 | .init = test_cache_init, |
231 | .update = test_cache_update, |
232 | .move = test_cache_move, |
233 | .port_info = vcap_test_port_info, |
234 | }; |
235 | |
236 | static struct vcap_control test_vctrl = { |
237 | .vcaps = kunit_test_vcaps, |
238 | .stats = &kunit_test_vcap_stats, |
239 | .ops = &test_callbacks, |
240 | }; |
241 | |
242 | static void vcap_test_api_init(struct vcap_admin *admin) |
243 | { |
244 | /* Initialize the shared objects */ |
245 | INIT_LIST_HEAD(list: &test_vctrl.list); |
246 | INIT_LIST_HEAD(list: &admin->list); |
247 | INIT_LIST_HEAD(list: &admin->rules); |
248 | INIT_LIST_HEAD(list: &admin->enabled); |
249 | mutex_init(&admin->lock); |
250 | list_add_tail(new: &admin->list, head: &test_vctrl.list); |
251 | memset(test_updateaddr, 0, sizeof(test_updateaddr)); |
252 | test_updateaddridx = 0; |
253 | test_pr_bufferidx = 0; |
254 | test_pr_idx = 0; |
255 | } |
256 | |
257 | /* callback used by the show_admin function */ |
258 | static __printf(2, 3) |
259 | int test_prf(void *out, const char *fmt, ...) |
260 | { |
261 | static char test_buffer[TEST_BUF_SZ]; |
262 | va_list args; |
263 | int idx, cnt; |
264 | |
265 | if (test_pr_bufferidx >= TEST_BUF_CNT) { |
266 | pr_err("%s:%d: overflow: %d\n" , __func__, __LINE__, |
267 | test_pr_bufferidx); |
268 | return 0; |
269 | } |
270 | |
271 | va_start(args, fmt); |
272 | cnt = vscnprintf(buf: test_buffer, TEST_BUF_SZ, fmt, args); |
273 | va_end(args); |
274 | |
275 | for (idx = 0; idx < cnt; ++idx) { |
276 | test_pr_buffer[test_pr_bufferidx][test_pr_idx] = |
277 | test_buffer[idx]; |
278 | if (test_buffer[idx] == '\n') { |
279 | test_pr_buffer[test_pr_bufferidx][++test_pr_idx] = 0; |
280 | test_pr_idx = 0; |
281 | test_pr_bufferidx++; |
282 | } else { |
283 | ++test_pr_idx; |
284 | } |
285 | } |
286 | |
287 | return cnt; |
288 | } |
289 | |
290 | /* Define the test cases. */ |
291 | |
292 | static void vcap_api_addr_keyset_test(struct kunit *test) |
293 | { |
294 | u32 keydata[12] = { |
295 | 0x40450042, 0x000feaf3, 0x00000003, 0x00050600, |
296 | 0x10203040, 0x00075880, 0x633c6864, 0x00040003, |
297 | 0x00000020, 0x00000008, 0x00000240, 0x00000000, |
298 | }; |
299 | u32 mskdata[12] = { |
300 | 0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff, |
301 | 0x00000000, 0xfff00000, 0x00000000, 0xfff3fffc, |
302 | 0xffffffc0, 0xffffffff, 0xfffffc03, 0xffffffff, |
303 | }; |
304 | u32 actdata[12] = {}; |
305 | struct vcap_admin admin = { |
306 | .vtype = VCAP_TYPE_IS2, |
307 | .cache = { |
308 | .keystream = keydata, |
309 | .maskstream = mskdata, |
310 | .actionstream = actdata, |
311 | }, |
312 | }; |
313 | enum vcap_keyfield_set keysets[10]; |
314 | struct vcap_keyset_list matches; |
315 | int ret, idx, addr; |
316 | |
317 | vcap_test_api_init(admin: &admin); |
318 | |
319 | /* Go from higher to lower addresses searching for a keyset */ |
320 | matches.keysets = keysets; |
321 | matches.cnt = 0; |
322 | matches.max = ARRAY_SIZE(keysets); |
323 | for (idx = ARRAY_SIZE(keydata) - 1, addr = 799; idx > 0; |
324 | --idx, --addr) { |
325 | admin.cache.keystream = &keydata[idx]; |
326 | admin.cache.maskstream = &mskdata[idx]; |
327 | ret = vcap_addr_keysets(vctrl: &test_vctrl, ndev: &test_netdev, admin: &admin, |
328 | addr, kslist: &matches); |
329 | KUNIT_EXPECT_EQ(test, -EINVAL, ret); |
330 | } |
331 | |
332 | /* Finally we hit the start of the rule */ |
333 | admin.cache.keystream = &keydata[idx]; |
334 | admin.cache.maskstream = &mskdata[idx]; |
335 | matches.cnt = 0; |
336 | ret = vcap_addr_keysets(vctrl: &test_vctrl, ndev: &test_netdev, admin: &admin, |
337 | addr, kslist: &matches); |
338 | KUNIT_EXPECT_EQ(test, 0, ret); |
339 | KUNIT_EXPECT_EQ(test, matches.cnt, 1); |
340 | KUNIT_EXPECT_EQ(test, matches.keysets[0], VCAP_KFS_MAC_ETYPE); |
341 | } |
342 | |
343 | static void vcap_api_show_admin_raw_test(struct kunit *test) |
344 | { |
345 | u32 keydata[4] = { |
346 | 0x40450042, 0x000feaf3, 0x00000003, 0x00050600, |
347 | }; |
348 | u32 mskdata[4] = { |
349 | 0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff, |
350 | }; |
351 | u32 actdata[12] = {}; |
352 | struct vcap_admin admin = { |
353 | .vtype = VCAP_TYPE_IS2, |
354 | .cache = { |
355 | .keystream = keydata, |
356 | .maskstream = mskdata, |
357 | .actionstream = actdata, |
358 | }, |
359 | .first_valid_addr = 786, |
360 | .last_valid_addr = 788, |
361 | }; |
362 | struct vcap_rule_internal ri = { |
363 | .ndev = &test_netdev, |
364 | }; |
365 | struct vcap_output_print out = { |
366 | .prf = (void *)test_prf, |
367 | }; |
368 | const char *test_expected = |
369 | " addr: 786, X6 rule, keysets: VCAP_KFS_MAC_ETYPE\n" ; |
370 | int ret; |
371 | |
372 | vcap_test_api_init(admin: &admin); |
373 | list_add_tail(new: &ri.list, head: &admin.rules); |
374 | |
375 | ret = vcap_show_admin_raw(vctrl: &test_vctrl, admin: &admin, out: &out); |
376 | KUNIT_EXPECT_EQ(test, 0, ret); |
377 | KUNIT_EXPECT_STREQ(test, test_expected, test_pr_buffer[0]); |
378 | } |
379 | |
380 | static const char * const test_admin_info_expect[] = { |
381 | "name: is2\n" , |
382 | "rows: 256\n" , |
383 | "sw_count: 12\n" , |
384 | "sw_width: 52\n" , |
385 | "sticky_width: 1\n" , |
386 | "act_width: 110\n" , |
387 | "default_cnt: 73\n" , |
388 | "require_cnt_dis: 0\n" , |
389 | "version: 1\n" , |
390 | "vtype: 4\n" , |
391 | "vinst: 0\n" , |
392 | "ingress: 1\n" , |
393 | "first_cid: 10000\n" , |
394 | "last_cid: 19999\n" , |
395 | "lookups: 4\n" , |
396 | "first_valid_addr: 0\n" , |
397 | "last_valid_addr: 3071\n" , |
398 | "last_used_addr: 794\n" , |
399 | }; |
400 | |
401 | static void vcap_api_show_admin_test(struct kunit *test) |
402 | { |
403 | struct vcap_admin admin = { |
404 | .vtype = VCAP_TYPE_IS2, |
405 | .first_cid = 10000, |
406 | .last_cid = 19999, |
407 | .lookups = 4, |
408 | .last_valid_addr = 3071, |
409 | .first_valid_addr = 0, |
410 | .last_used_addr = 794, |
411 | .ingress = true, |
412 | }; |
413 | struct vcap_output_print out = { |
414 | .prf = (void *)test_prf, |
415 | }; |
416 | int idx; |
417 | |
418 | vcap_test_api_init(admin: &admin); |
419 | |
420 | vcap_show_admin_info(vctrl: &test_vctrl, admin: &admin, out: &out); |
421 | for (idx = 0; idx < test_pr_bufferidx; ++idx) { |
422 | /* pr_info("log[%02d]: %s", idx, test_pr_buffer[idx]); */ |
423 | KUNIT_EXPECT_STREQ(test, test_admin_info_expect[idx], |
424 | test_pr_buffer[idx]); |
425 | } |
426 | } |
427 | |
428 | static const char * const test_admin_expect[] = { |
429 | "name: is2\n" , |
430 | "rows: 256\n" , |
431 | "sw_count: 12\n" , |
432 | "sw_width: 52\n" , |
433 | "sticky_width: 1\n" , |
434 | "act_width: 110\n" , |
435 | "default_cnt: 73\n" , |
436 | "require_cnt_dis: 0\n" , |
437 | "version: 1\n" , |
438 | "vtype: 4\n" , |
439 | "vinst: 0\n" , |
440 | "ingress: 1\n" , |
441 | "first_cid: 8000000\n" , |
442 | "last_cid: 8199999\n" , |
443 | "lookups: 4\n" , |
444 | "first_valid_addr: 0\n" , |
445 | "last_valid_addr: 3071\n" , |
446 | "last_used_addr: 794\n" , |
447 | "\n" , |
448 | "rule: 100, addr: [794,799], X6, ctr[0]: 0, hit: 0\n" , |
449 | " chain_id: 0\n" , |
450 | " user: 0\n" , |
451 | " priority: 0\n" , |
452 | " state: permanent\n" , |
453 | " keysets: VCAP_KFS_MAC_ETYPE\n" , |
454 | " keyset_sw: 6\n" , |
455 | " keyset_sw_regs: 2\n" , |
456 | " ETYPE_LEN_IS: W1: 1/1\n" , |
457 | " IF_IGR_PORT_MASK: W32: 0xffabcd01/0xffffffff\n" , |
458 | " IF_IGR_PORT_MASK_RNG: W4: 5/15\n" , |
459 | " L2_DMAC: W48: 01:02:03:04:05:06/ff:ff:ff:ff:ff:ff\n" , |
460 | " L2_PAYLOAD_ETYPE: W64: 0x9000002000000081/0xff000000000000ff\n" , |
461 | " L2_SMAC: W48: b1:9e:34:32:75:88/ff:ff:ff:ff:ff:ff\n" , |
462 | " LOOKUP_FIRST_IS: W1: 1/1\n" , |
463 | " TYPE: W4: 0/15\n" , |
464 | " actionset: VCAP_AFS_BASE_TYPE\n" , |
465 | " actionset_sw: 3\n" , |
466 | " actionset_sw_regs: 4\n" , |
467 | " CNT_ID: W12: 100\n" , |
468 | " MATCH_ID: W16: 1\n" , |
469 | " MATCH_ID_MASK: W16: 1\n" , |
470 | " POLICE_ENA: W1: 1\n" , |
471 | " PORT_MASK: W68: 0x0514670115f3324589\n" , |
472 | }; |
473 | |
474 | static void vcap_api_show_admin_rule_test(struct kunit *test) |
475 | { |
476 | u32 keydata[] = { |
477 | 0x40450042, 0x000feaf3, 0x00000003, 0x00050600, |
478 | 0x10203040, 0x00075880, 0x633c6864, 0x00040003, |
479 | 0x00000020, 0x00000008, 0x00000240, 0x00000000, |
480 | }; |
481 | u32 mskdata[] = { |
482 | 0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff, |
483 | 0x00000000, 0xfff00000, 0x00000000, 0xfff3fffc, |
484 | 0xffffffc0, 0xffffffff, 0xfffffc03, 0xffffffff, |
485 | }; |
486 | u32 actdata[] = { |
487 | 0x00040002, 0xf3324589, 0x14670115, 0x00000005, |
488 | 0x00000000, 0x00100000, 0x06400010, 0x00000000, |
489 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, |
490 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, |
491 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, |
492 | 0x00000000, 0x00000000, 0x00000000, 0x00000000, |
493 | }; |
494 | struct vcap_admin admin = { |
495 | .vtype = VCAP_TYPE_IS2, |
496 | .first_cid = 8000000, |
497 | .last_cid = 8199999, |
498 | .lookups = 4, |
499 | .last_valid_addr = 3071, |
500 | .first_valid_addr = 0, |
501 | .last_used_addr = 794, |
502 | .ingress = true, |
503 | .cache = { |
504 | .keystream = keydata, |
505 | .maskstream = mskdata, |
506 | .actionstream = actdata, |
507 | }, |
508 | }; |
509 | struct vcap_rule_internal ri = { |
510 | .admin = &admin, |
511 | .data = { |
512 | .id = 100, |
513 | .keyset = VCAP_KFS_MAC_ETYPE, |
514 | .actionset = VCAP_AFS_BASE_TYPE, |
515 | }, |
516 | .size = 6, |
517 | .keyset_sw = 6, |
518 | .keyset_sw_regs = 2, |
519 | .actionset_sw = 3, |
520 | .actionset_sw_regs = 4, |
521 | .addr = 794, |
522 | .vctrl = &test_vctrl, |
523 | }; |
524 | struct vcap_output_print out = { |
525 | .prf = (void *)test_prf, |
526 | }; |
527 | int ret, idx; |
528 | |
529 | vcap_test_api_init(admin: &admin); |
530 | list_add_tail(new: &ri.list, head: &admin.rules); |
531 | |
532 | ret = vcap_show_admin(vctrl: &test_vctrl, admin: &admin, out: &out); |
533 | KUNIT_EXPECT_EQ(test, 0, ret); |
534 | for (idx = 0; idx < test_pr_bufferidx; ++idx) { |
535 | /* pr_info("log[%02d]: %s", idx, test_pr_buffer[idx]); */ |
536 | KUNIT_EXPECT_STREQ(test, test_admin_expect[idx], |
537 | test_pr_buffer[idx]); |
538 | } |
539 | } |
540 | |
541 | static struct kunit_case vcap_api_debugfs_test_cases[] = { |
542 | KUNIT_CASE(vcap_api_addr_keyset_test), |
543 | KUNIT_CASE(vcap_api_show_admin_raw_test), |
544 | KUNIT_CASE(vcap_api_show_admin_test), |
545 | KUNIT_CASE(vcap_api_show_admin_rule_test), |
546 | {} |
547 | }; |
548 | |
549 | static struct kunit_suite vcap_api_debugfs_test_suite = { |
550 | .name = "VCAP_API_DebugFS_Testsuite" , |
551 | .test_cases = vcap_api_debugfs_test_cases, |
552 | }; |
553 | |
554 | kunit_test_suite(vcap_api_debugfs_test_suite); |
555 | |