projects/linux·blob assoc-array-fixes-v2 · refs

607 lines · 18.5 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2//
3// node-tree-test.c - An application of Kunit to test node tree.
4//
5// Copyright (c) 2026 Takashi Sakamoto
6//
7// This file can not be built independently since it is intentionally included in core-topology.c.
8
9#include <kunit/test.h>
10#include <kunit/test-bug.h>
11#include <kunit/device.h>
12
13struct private_data {
14 struct fw_card *card;
15 unsigned int release_count;
16};
17
18static int node_tree_test_init(struct kunit *test)
19{
20 struct private_data *data;
21
22 data = kunit_kzalloc(test, sizeof(*data), GFP_KERNEL);
23 KUNIT_ASSERT_NOT_NULL(test, data);
24
25 data->card = kunit_kzalloc(test, sizeof(struct fw_card), GFP_KERNEL);
26 KUNIT_ASSERT_NOT_NULL(test, data->card);
27
28 data->card->device = kunit_device_register(test, "dummy-device");
29 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, data->card->device);
30
31 test->priv = data;
32
33 return 0;
34}
35
36static void node_tree_test_exit(struct kunit *test)
37{
38 struct private_data *data = test->priv;
39
40 kunit_device_unregister(test, data->card->device);
41 kunit_kfree(test, data->card);
42 kunit_kfree(test, data);
43}
44
45static void release_fw_node(struct fw_card *card, struct fw_node *node, struct fw_node *parent)
46{
47 struct private_data *data = kunit_get_current_test()->priv;
48
49 fw_node_put(node);
50 ++data->release_count;
51}
52
53static void node_tree_test_two_nodes(struct kunit *test)
54{
55 // root
56 // ++============++
57 // || phy 1 ||
58 // || P0 P1 P2 ||
59 // ++===|==|==|==++
60 // |
61 // +-----+
62 // |
63 // ++===|==x==x==++
64 // || P0 P1 P2 ||
65 // || phy 0 ||
66 // ++============++
67 //
68 static const u32 self_id_sequence[] = {
69 0x80000080,
70 0x8100005e,
71 };
72 struct private_data *data = test->priv;
73 struct fw_card *card = data->card;
74
75 card->node_id = LOCAL_BUS | 0x01;
76
77 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
78 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
79 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
80
81 struct fw_node *node = card->root_node;
82 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
83 KUNIT_EXPECT_EQ(test, node->port_count, 3);
84 KUNIT_EXPECT_NULL(test, node->ports[0]);
85 KUNIT_EXPECT_NULL(test, node->ports[1]);
86 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
87
88 struct fw_node *parent = node;
89 node = parent->ports[2];
90 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
91 KUNIT_EXPECT_EQ(test, node->port_count, 1);
92 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
93
94 ++card->color;
95 for_each_fw_node(card, card->root_node, release_fw_node);
96 KUNIT_EXPECT_EQ(test, data->release_count, 2);
97}
98
99static void node_tree_test_two_nodes_1394a(struct kunit *test)
100{
101 // root
102 // ++===============++
103 // || phy 0 ||
104 // || P0 P1 P2 P3 ||
105 // ++===|==|==|==|==++
106 // |
107 // +--+
108 // |
109 // ++===|==|==|==|==|==++
110 // || P0 P1 P2 P3 P4 ||
111 // || phy 1 ||
112 // ++==================++
113 //
114 // NOTE: Just for Self-ID Packets Zero and One.
115 static const u32 self_id_sequence[] = {
116 0x80000065, 0x80814000,
117 0x8100005d, 0x81810000,
118 };
119 struct private_data *data = test->priv;
120 struct fw_card *card = data->card;
121
122 card->node_id = LOCAL_BUS | 0x01;
123
124 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
125 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
126 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
127
128 struct fw_node *node = card->root_node;
129 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
130 KUNIT_EXPECT_EQ(test, node->port_count, 4);
131 KUNIT_EXPECT_NULL(test, node->ports[0]);
132 KUNIT_EXPECT_NULL(test, node->ports[1]);
133 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
134 KUNIT_EXPECT_NULL(test, node->ports[3]);
135
136 struct fw_node *parent = node;
137 node = parent->ports[2];
138 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
139 KUNIT_EXPECT_EQ(test, node->port_count, 5);
140 KUNIT_EXPECT_NULL(test, node->ports[0]);
141 KUNIT_EXPECT_PTR_EQ(test, node->ports[1], parent);
142 KUNIT_EXPECT_NULL(test, node->ports[2]);
143 KUNIT_EXPECT_NULL(test, node->ports[3]);
144 KUNIT_EXPECT_NULL(test, node->ports[4]);
145
146 ++card->color;
147 for_each_fw_node(card, card->root_node, release_fw_node);
148 KUNIT_EXPECT_EQ(test, data->release_count, 2);
149}
150
151static void node_tree_test_three_nodes_case0(struct kunit *test)
152{
153 // root
154 // ++============++
155 // || phy 2 ||
156 // || P0 P1 P2 ||
157 // ++===|==|==|==++
158 // | |
159 // +--+ +-----------------+
160 // | |
161 // ++===|==|==x==++ ++===|==|==|==++
162 // || P0 P1 P2 || || P0 P1 P2 ||
163 // || phy 0 || || phy 1 ||
164 // ++============++ ++============++
165 //
166 static const u32 self_id_sequence[] = {
167 0x80000060,
168 0x81000058,
169 0x820000dc,
170 };
171 struct private_data *data = test->priv;
172 struct fw_card *card = data->card;
173
174 card->node_id = LOCAL_BUS | 0x02;
175
176 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
177 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
178 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
179
180 struct fw_node *node = card->root_node;
181 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
182 KUNIT_EXPECT_EQ(test, node->port_count, 3);
183 KUNIT_EXPECT_NOT_NULL(test, node->ports[0]);
184 KUNIT_EXPECT_NULL(test, node->ports[1]);
185 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
186
187 struct fw_node *parent = node;
188 node = parent->ports[0];
189 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
190 KUNIT_EXPECT_EQ(test, node->port_count, 2);
191 KUNIT_EXPECT_NULL(test, node->ports[0]);
192 KUNIT_EXPECT_PTR_EQ(test, node->ports[1], parent);
193
194 node = parent->ports[2];
195 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
196 KUNIT_EXPECT_EQ(test, node->port_count, 3);
197 KUNIT_EXPECT_NULL(test, node->ports[0]);
198 KUNIT_EXPECT_NULL(test, node->ports[1]);
199 KUNIT_EXPECT_PTR_EQ(test, node->ports[2], parent);
200
201 ++card->color;
202 for_each_fw_node(card, card->root_node, release_fw_node);
203 KUNIT_EXPECT_EQ(test, data->release_count, 3);
204}
205
206static void node_tree_test_three_nodes_case1(struct kunit *test)
207{
208 // root
209 // ++============++
210 // || phy 2 ||
211 // || P0 P1 P2 ||
212 // ++===|==|==x==++
213 // |
214 // | +-----------+
215 // | | |
216 // ++===|==|==|==++ ++===|==x==x==++
217 // || P0 P1 P2 || || P0 P1 P2 ||
218 // || phy 1 || || phy 0 ||
219 // ++============++ ++============++
220 //
221 static const u32 self_id_sequence[] = {
222 0x80000080,
223 0x8100006c,
224 0x82000070,
225 };
226 struct private_data *data = test->priv;
227 struct fw_card *card = data->card;
228
229 card->node_id = LOCAL_BUS | 0x02;
230
231 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
232 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
233 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
234
235 struct fw_node *node = card->root_node;
236 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
237 KUNIT_EXPECT_EQ(test, node->port_count, 2);
238 KUNIT_EXPECT_NULL(test, node->ports[0]);
239 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
240
241 struct fw_node *parent = node;
242 node = parent->ports[1];
243 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
244 KUNIT_EXPECT_EQ(test, node->port_count, 3);
245 KUNIT_EXPECT_NULL(test, node->ports[0]);
246 KUNIT_EXPECT_PTR_EQ(test, node->ports[1], parent);
247 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
248
249 parent = node;
250 node = parent->ports[2];
251 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
252 KUNIT_EXPECT_EQ(test, node->port_count, 1);
253 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
254
255 ++card->color;
256 for_each_fw_node(card, card->root_node, release_fw_node);
257 KUNIT_EXPECT_EQ(test, data->release_count, 3);
258}
259
260static void node_tree_test_four_nodes_case0(struct kunit *test)
261{
262 // root
263 // ++============++
264 // || phy 3 ||
265 // || P0 P1 P2 ||
266 // ++===|==|==|==++
267 // |
268 // | +-----------+ +--------------+
269 // | | | | |
270 // ++===|==|==|==++ ++===|==|==x==++ ++===|==x==x==++
271 // || P0 P1 P2 || || P0 P1 P2 || || P0 P1 P2 ||
272 // || phy 2 || || phy 1 || || phy 0 ||
273 // ++============++ ++============++ ++============++
274 //
275 static const u32 self_id_sequence[] = {
276 0x80000080,
277 0x810000b0,
278 0x8200006c,
279 0x83000074,
280 };
281 struct private_data *data = test->priv;
282 struct fw_card *card = data->card;
283
284 card->node_id = LOCAL_BUS | 0x03;
285
286 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
287 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
288 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
289
290 struct fw_node *node = card->root_node;
291 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x03);
292 KUNIT_EXPECT_EQ(test, node->port_count, 3);
293 KUNIT_EXPECT_NULL(test, node->ports[0]);
294 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
295 KUNIT_EXPECT_NULL(test, node->ports[2]);
296
297 struct fw_node *parent = node;
298 node = parent->ports[1];
299 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
300 KUNIT_EXPECT_EQ(test, node->port_count, 3);
301 KUNIT_EXPECT_NULL(test, node->ports[0]);
302 KUNIT_EXPECT_PTR_EQ(test, node->ports[1], parent);
303 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
304
305 parent = node;
306 node = parent->ports[2];
307 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
308 KUNIT_EXPECT_EQ(test, node->port_count, 2);
309 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
310 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
311
312 parent = node;
313 node = parent->ports[1];
314 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
315 KUNIT_EXPECT_EQ(test, node->port_count, 1);
316 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
317
318 ++card->color;
319 for_each_fw_node(card, card->root_node, release_fw_node);
320 KUNIT_EXPECT_EQ(test, data->release_count, 4);
321}
322
323static void node_tree_test_four_nodes_case1(struct kunit *test)
324{
325 // root
326 // ++============++
327 // || phy 3 ||
328 // || P0 P1 P2 ||
329 // ++===|==|==x==++
330 // |
331 // | +--------------------------------+
332 // | | +-----------+ |
333 // ++===|==|==|==++ ++===|==x==x==++ ++===|==|==|==++
334 // || P0 P1 P2 || || P0 P1 P2 || || P0 P1 P2 ||
335 // || phy 2 || || phy 1 || || phy 0 ||
336 // ++============++ ++============++ ++============++
337 //
338 static const u32 self_id_sequence[] = {
339 0x80000094,
340 0x81000080,
341 0x820000bc,
342 0x830000d0,
343 };
344 struct private_data *data = test->priv;
345 struct fw_card *card = data->card;
346
347 card->node_id = LOCAL_BUS | 0x03;
348
349 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
350 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
351 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
352
353 struct fw_node *node = card->root_node;
354 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x03);
355 KUNIT_EXPECT_EQ(test, node->port_count, 2);
356 KUNIT_EXPECT_NOT_NULL(test, node->ports[0]);
357 KUNIT_EXPECT_NULL(test, node->ports[1]);
358
359 struct fw_node *parent = node;
360 node = parent->ports[0];
361 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
362 KUNIT_EXPECT_EQ(test, node->port_count, 3);
363 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
364 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
365 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
366
367 parent = node;
368 node = parent->ports[2];
369 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
370 KUNIT_EXPECT_EQ(test, node->port_count, 1);
371 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
372
373 node = parent->ports[1];
374 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
375 KUNIT_EXPECT_EQ(test, node->port_count, 3);
376 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
377 KUNIT_EXPECT_NULL(test, node->ports[1]);
378 KUNIT_EXPECT_NULL(test, node->ports[2]);
379
380 ++card->color;
381 for_each_fw_node(card, card->root_node, release_fw_node);
382 KUNIT_EXPECT_EQ(test, data->release_count, 4);
383}
384
385static void node_tree_test_four_nodes_case2(struct kunit *test)
386{
387 // root
388 // ++============++
389 // || phy 3 ||
390 // || P0 P1 P2 ||
391 // ++===|==|==|==++
392 // | |
393 // | +-----------------------------+
394 // | +--------------+ |
395 // ++===|==|==x==++ ++===|==|==|==++ ++===|==x==x==++
396 // || P0 P1 P2 || || P0 P1 P2 || || P0 P1 P2 ||
397 // || phy 1 || || phy 0 || || phy 2 ||
398 // ++============++ ++============++ ++============++
399 //
400 static const u32 self_id_sequence[] = {
401 0x80000094,
402 0x810000b0,
403 0x82000080,
404 0x830000dc,
405 };
406 struct private_data *data = test->priv;
407 struct fw_card *card = data->card;
408
409 card->node_id = LOCAL_BUS | 0x03;
410
411 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
412 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
413 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
414
415 struct fw_node *node = card->root_node;
416 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x03);
417 KUNIT_EXPECT_EQ(test, node->port_count, 3);
418 KUNIT_EXPECT_NOT_NULL(test, node->ports[0]);
419 KUNIT_EXPECT_NULL(test, node->ports[1]);
420 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
421
422 struct fw_node *parent = node;
423 node = parent->ports[2];
424 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
425 KUNIT_EXPECT_EQ(test, node->port_count, 1);
426 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
427
428 node = parent->ports[0];
429 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
430 KUNIT_EXPECT_EQ(test, node->port_count, 2);
431 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
432 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
433
434 parent = node;
435 node = parent->ports[1];
436 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
437 KUNIT_EXPECT_EQ(test, node->port_count, 3);
438 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
439 KUNIT_EXPECT_NULL(test, node->ports[1]);
440 KUNIT_EXPECT_NULL(test, node->ports[2]);
441
442 ++card->color;
443 for_each_fw_node(card, card->root_node, release_fw_node);
444 KUNIT_EXPECT_EQ(test, data->release_count, 4);
445}
446
447static void node_tree_test_four_nodes_case3(struct kunit *test)
448{
449 // root
450 // ++============++
451 // || phy 3 ||
452 // || P0 P1 P2 ||
453 // ++===|==|==|==++
454 // | | +--------------------------------+
455 // | +--------------------+ |
456 // | | |
457 // ++===|==|==x==++ ++===|==|==|==++ ++===|==|==x==++
458 // || P0 P1 P2 || || P0 P1 P2 || || P0 P1 P2 ||
459 // || phy 0 || || phy 1 || || phy 2 ||
460 // ++============++ ++============++ ++============++
461 //
462 static const u32 self_id_sequence[] = {
463 0x80000090,
464 0x81000058,
465 0x82000060,
466 0x830000fc,
467 };
468 struct private_data *data = test->priv;
469 struct fw_card *card = data->card;
470
471 card->node_id = LOCAL_BUS | 0x03;
472
473 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
474 KUNIT_EXPECT_NOT_NULL(test, card->local_node);
475 KUNIT_EXPECT_PTR_EQ(test, card->local_node, card->root_node);
476
477 struct fw_node *node = card->root_node;
478 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x03);
479 KUNIT_EXPECT_EQ(test, node->port_count, 3);
480 KUNIT_EXPECT_NOT_NULL(test, node->ports[0]);
481 KUNIT_EXPECT_NOT_NULL(test, node->ports[1]);
482 KUNIT_EXPECT_NOT_NULL(test, node->ports[2]);
483
484 struct fw_node *parent = node;
485 node = parent->ports[2];
486 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x02);
487 KUNIT_EXPECT_EQ(test, node->port_count, 2);
488 KUNIT_EXPECT_NULL(test, node->ports[0]);
489 KUNIT_EXPECT_PTR_EQ(test, node->ports[1], parent);
490
491 node = parent->ports[1];
492 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x01);
493 KUNIT_EXPECT_EQ(test, node->port_count, 3);
494 KUNIT_EXPECT_NULL(test, node->ports[0]);
495 KUNIT_EXPECT_NULL(test, node->ports[1]);
496 KUNIT_EXPECT_PTR_EQ(test, node->ports[2], parent);
497
498 node = parent->ports[0];
499 KUNIT_EXPECT_EQ(test, node->node_id, LOCAL_BUS | 0x00);
500 KUNIT_EXPECT_EQ(test, node->port_count, 2);
501 KUNIT_EXPECT_PTR_EQ(test, node->ports[0], parent);
502 KUNIT_EXPECT_NULL(test, node->ports[1]);
503
504 ++card->color;
505 for_each_fw_node(card, card->root_node, release_fw_node);
506 KUNIT_EXPECT_EQ(test, data->release_count, 4);
507}
508
509static void node_tree_test_invalid_extended_self_id_sequence(struct kunit *test)
510{
511 // Use the same node tree as node_tree_test_four_nodes_case1, except for the invalid
512 // content of self ID packet for the phy 3.
513 static const u32 self_id_sequence[] = {
514 0x80000094,
515 0x81000080,
516 0x820000bc,
517 0x830000d1, // Invalid.
518 };
519 struct private_data *data = test->priv;
520 struct fw_card *card = data->card;
521
522 card->node_id = LOCAL_BUS | 0x03;
523
524 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
525 KUNIT_EXPECT_NULL(test, card->local_node);
526}
527
528static void node_tree_test_invalid_phy_id(struct kunit *test)
529{
530 // Use the same node tree as node_tree_test_four_nodes_case1, except for the invalid
531 // phy ID for phy 3.
532 static const u32 self_id_sequence[] = {
533 0x80000094,
534 0x81000080,
535 0x820000bc,
536 0x8f0000d0, // Invalid.
537 };
538 struct private_data *data = test->priv;
539 struct fw_card *card = data->card;
540
541 card->node_id = LOCAL_BUS | 0x03;
542
543 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
544 KUNIT_EXPECT_NULL(test, card->local_node);
545}
546
547static void node_tree_test_invalid_child_port_count(struct kunit *test)
548{
549 // Use the same node tree as node_tree_test_four_nodes_case1, except for the invalid
550 // count of child ports for phy 3.
551 static const u32 self_id_sequence[] = {
552 0x80000094,
553 0x81000080,
554 0x820000bc,
555 0x830000fc, // Invalid.
556 };
557 struct private_data *data = test->priv;
558 struct fw_card *card = data->card;
559
560 card->node_id = LOCAL_BUS | 0x03;
561
562 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
563 KUNIT_EXPECT_NULL(test, card->local_node);
564}
565
566static void node_tree_test_invalid_parent_port_count(struct kunit *test)
567{
568 // Use the same node tree as node_tree_test_four_nodes_case1, except for the invalid
569 // count of parent ports for phy 3.
570 static const u32 self_id_sequence[] = {
571 0x80000094,
572 0x81000080,
573 0x820000bc,
574 0x830000e8, // Invalid.
575 };
576 struct private_data *data = test->priv;
577 struct fw_card *card = data->card;
578
579 card->node_id = LOCAL_BUS | 0x03;
580
581 card->local_node = build_tree(card, self_id_sequence, ARRAY_SIZE(self_id_sequence), 123);
582 KUNIT_EXPECT_NULL(test, card->local_node);
583}
584
585static struct kunit_case node_tree_test_cases[] = {
586 KUNIT_CASE(node_tree_test_two_nodes),
587 KUNIT_CASE(node_tree_test_two_nodes_1394a),
588 KUNIT_CASE(node_tree_test_three_nodes_case0),
589 KUNIT_CASE(node_tree_test_three_nodes_case1),
590 KUNIT_CASE(node_tree_test_four_nodes_case0),
591 KUNIT_CASE(node_tree_test_four_nodes_case1),
592 KUNIT_CASE(node_tree_test_four_nodes_case2),
593 KUNIT_CASE(node_tree_test_four_nodes_case3),
594 KUNIT_CASE(node_tree_test_invalid_extended_self_id_sequence),
595 KUNIT_CASE(node_tree_test_invalid_phy_id),
596 KUNIT_CASE(node_tree_test_invalid_child_port_count),
597 KUNIT_CASE(node_tree_test_invalid_parent_port_count),
598 {}
599};
600
601static struct kunit_suite node_tree_test_suite = {
602 .name = "firewire-node-tree",
603 .init = node_tree_test_init,
604 .exit = node_tree_test_exit,
605 .test_cases = node_tree_test_cases,
606};
607kunit_test_suite(node_tree_test_suite);