1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KUnit test for the Kernel Linked-list structures. 4 * 5 * Copyright (C) 2019, Google LLC. 6 * Author: David Gow <davidgow@google.com> 7 */ 8 #include <kunit/test.h> 9 10 #include <linux/list.h> 11 12 struct list_test_struct { 13 int data; 14 struct list_head list; 15 }; 16 17 static void list_test_list_init(struct kunit *test) 18 { 19 /* Test the different ways of initialising a list. */ 20 struct list_head list1 = LIST_HEAD_INIT(list1); 21 struct list_head list2; 22 LIST_HEAD(list3); 23 struct list_head *list4; 24 struct list_head *list5; 25 26 INIT_LIST_HEAD(&list2); 27 28 list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL); 29 INIT_LIST_HEAD(list4); 30 31 list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL); 32 memset(list5, 0xFF, sizeof(*list5)); 33 INIT_LIST_HEAD(list5); 34 35 /* list_empty_careful() checks both next and prev. */ 36 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1)); 37 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 38 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3)); 39 KUNIT_EXPECT_TRUE(test, list_empty_careful(list4)); 40 KUNIT_EXPECT_TRUE(test, list_empty_careful(list5)); 41 42 kfree(list4); 43 kfree(list5); 44 } 45 46 static void list_test_list_add(struct kunit *test) 47 { 48 struct list_head a, b; 49 LIST_HEAD(list); 50 51 list_add(&a, &list); 52 list_add(&b, &list); 53 54 /* should be [list] -> b -> a */ 55 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 56 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 57 KUNIT_EXPECT_PTR_EQ(test, b.next, &a); 58 } 59 60 static void list_test_list_add_tail(struct kunit *test) 61 { 62 struct list_head a, b; 63 LIST_HEAD(list); 64 65 list_add_tail(&a, &list); 66 list_add_tail(&b, &list); 67 68 /* should be [list] -> a -> b */ 69 KUNIT_EXPECT_PTR_EQ(test, list.next, &a); 70 KUNIT_EXPECT_PTR_EQ(test, a.prev, &list); 71 KUNIT_EXPECT_PTR_EQ(test, a.next, &b); 72 } 73 74 static void list_test_list_del(struct kunit *test) 75 { 76 struct list_head a, b; 77 LIST_HEAD(list); 78 79 list_add_tail(&a, &list); 80 list_add_tail(&b, &list); 81 82 /* before: [list] -> a -> b */ 83 list_del(&a); 84 85 /* now: [list] -> b */ 86 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 87 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 88 } 89 90 static void list_test_list_replace(struct kunit *test) 91 { 92 struct list_head a_old, a_new, b; 93 LIST_HEAD(list); 94 95 list_add_tail(&a_old, &list); 96 list_add_tail(&b, &list); 97 98 /* before: [list] -> a_old -> b */ 99 list_replace(&a_old, &a_new); 100 101 /* now: [list] -> a_new -> b */ 102 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new); 103 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new); 104 } 105 106 static void list_test_list_replace_init(struct kunit *test) 107 { 108 struct list_head a_old, a_new, b; 109 LIST_HEAD(list); 110 111 list_add_tail(&a_old, &list); 112 list_add_tail(&b, &list); 113 114 /* before: [list] -> a_old -> b */ 115 list_replace_init(&a_old, &a_new); 116 117 /* now: [list] -> a_new -> b */ 118 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new); 119 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new); 120 121 /* check a_old is empty (initialized) */ 122 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old)); 123 } 124 125 static void list_test_list_swap(struct kunit *test) 126 { 127 struct list_head a, b; 128 LIST_HEAD(list); 129 130 list_add_tail(&a, &list); 131 list_add_tail(&b, &list); 132 133 /* before: [list] -> a -> b */ 134 list_swap(&a, &b); 135 136 /* after: [list] -> b -> a */ 137 KUNIT_EXPECT_PTR_EQ(test, &b, list.next); 138 KUNIT_EXPECT_PTR_EQ(test, &a, list.prev); 139 140 KUNIT_EXPECT_PTR_EQ(test, &a, b.next); 141 KUNIT_EXPECT_PTR_EQ(test, &list, b.prev); 142 143 KUNIT_EXPECT_PTR_EQ(test, &list, a.next); 144 KUNIT_EXPECT_PTR_EQ(test, &b, a.prev); 145 } 146 147 static void list_test_list_del_init(struct kunit *test) 148 { 149 struct list_head a, b; 150 LIST_HEAD(list); 151 152 list_add_tail(&a, &list); 153 list_add_tail(&b, &list); 154 155 /* before: [list] -> a -> b */ 156 list_del_init(&a); 157 /* after: [list] -> b, a initialised */ 158 159 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 160 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 161 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a)); 162 } 163 164 static void list_test_list_del_init_careful(struct kunit *test) 165 { 166 /* NOTE: This test only checks the behaviour of this function in 167 * isolation. It does not verify memory model guarantees. 168 */ 169 struct list_head a, b; 170 LIST_HEAD(list); 171 172 list_add_tail(&a, &list); 173 list_add_tail(&b, &list); 174 175 /* before: [list] -> a -> b */ 176 list_del_init_careful(&a); 177 /* after: [list] -> b, a initialised */ 178 179 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 180 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 181 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a)); 182 } 183 184 static void list_test_list_move(struct kunit *test) 185 { 186 struct list_head a, b; 187 LIST_HEAD(list1); 188 LIST_HEAD(list2); 189 190 list_add_tail(&a, &list1); 191 list_add_tail(&b, &list2); 192 193 /* before: [list1] -> a, [list2] -> b */ 194 list_move(&a, &list2); 195 /* after: [list1] empty, [list2] -> a -> b */ 196 197 KUNIT_EXPECT_TRUE(test, list_empty(&list1)); 198 199 KUNIT_EXPECT_PTR_EQ(test, &a, list2.next); 200 KUNIT_EXPECT_PTR_EQ(test, &b, a.next); 201 } 202 203 static void list_test_list_move_tail(struct kunit *test) 204 { 205 struct list_head a, b; 206 LIST_HEAD(list1); 207 LIST_HEAD(list2); 208 209 list_add_tail(&a, &list1); 210 list_add_tail(&b, &list2); 211 212 /* before: [list1] -> a, [list2] -> b */ 213 list_move_tail(&a, &list2); 214 /* after: [list1] empty, [list2] -> b -> a */ 215 216 KUNIT_EXPECT_TRUE(test, list_empty(&list1)); 217 218 KUNIT_EXPECT_PTR_EQ(test, &b, list2.next); 219 KUNIT_EXPECT_PTR_EQ(test, &a, b.next); 220 } 221 222 static void list_test_list_bulk_move_tail(struct kunit *test) 223 { 224 struct list_head a, b, c, d, x, y; 225 struct list_head *list1_values[] = { &x, &b, &c, &y }; 226 struct list_head *list2_values[] = { &a, &d }; 227 struct list_head *ptr; 228 LIST_HEAD(list1); 229 LIST_HEAD(list2); 230 int i = 0; 231 232 list_add_tail(&x, &list1); 233 list_add_tail(&y, &list1); 234 235 list_add_tail(&a, &list2); 236 list_add_tail(&b, &list2); 237 list_add_tail(&c, &list2); 238 list_add_tail(&d, &list2); 239 240 /* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */ 241 list_bulk_move_tail(&y, &b, &c); 242 /* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */ 243 244 list_for_each(ptr, &list1) { 245 KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]); 246 i++; 247 } 248 KUNIT_EXPECT_EQ(test, i, 4); 249 i = 0; 250 list_for_each(ptr, &list2) { 251 KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]); 252 i++; 253 } 254 KUNIT_EXPECT_EQ(test, i, 2); 255 } 256 257 static void list_test_list_is_first(struct kunit *test) 258 { 259 struct list_head a, b; 260 LIST_HEAD(list); 261 262 list_add_tail(&a, &list); 263 list_add_tail(&b, &list); 264 265 KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list)); 266 KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list)); 267 } 268 269 static void list_test_list_is_last(struct kunit *test) 270 { 271 struct list_head a, b; 272 LIST_HEAD(list); 273 274 list_add_tail(&a, &list); 275 list_add_tail(&b, &list); 276 277 KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list)); 278 KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list)); 279 } 280 281 static void list_test_list_empty(struct kunit *test) 282 { 283 struct list_head a; 284 LIST_HEAD(list1); 285 LIST_HEAD(list2); 286 287 list_add_tail(&a, &list1); 288 289 KUNIT_EXPECT_FALSE(test, list_empty(&list1)); 290 KUNIT_EXPECT_TRUE(test, list_empty(&list2)); 291 } 292 293 static void list_test_list_empty_careful(struct kunit *test) 294 { 295 /* This test doesn't check correctness under concurrent access */ 296 struct list_head a; 297 LIST_HEAD(list1); 298 LIST_HEAD(list2); 299 300 list_add_tail(&a, &list1); 301 302 KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1)); 303 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 304 } 305 306 static void list_test_list_rotate_left(struct kunit *test) 307 { 308 struct list_head a, b; 309 LIST_HEAD(list); 310 311 list_add_tail(&a, &list); 312 list_add_tail(&b, &list); 313 314 /* before: [list] -> a -> b */ 315 list_rotate_left(&list); 316 /* after: [list] -> b -> a */ 317 318 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 319 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 320 KUNIT_EXPECT_PTR_EQ(test, b.next, &a); 321 } 322 323 static void list_test_list_rotate_to_front(struct kunit *test) 324 { 325 struct list_head a, b, c, d; 326 struct list_head *list_values[] = { &c, &d, &a, &b }; 327 struct list_head *ptr; 328 LIST_HEAD(list); 329 int i = 0; 330 331 list_add_tail(&a, &list); 332 list_add_tail(&b, &list); 333 list_add_tail(&c, &list); 334 list_add_tail(&d, &list); 335 336 /* before: [list] -> a -> b -> c -> d */ 337 list_rotate_to_front(&c, &list); 338 /* after: [list] -> c -> d -> a -> b */ 339 340 list_for_each(ptr, &list) { 341 KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]); 342 i++; 343 } 344 KUNIT_EXPECT_EQ(test, i, 4); 345 } 346 347 static void list_test_list_is_singular(struct kunit *test) 348 { 349 struct list_head a, b; 350 LIST_HEAD(list); 351 352 /* [list] empty */ 353 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 354 355 list_add_tail(&a, &list); 356 357 /* [list] -> a */ 358 KUNIT_EXPECT_TRUE(test, list_is_singular(&list)); 359 360 list_add_tail(&b, &list); 361 362 /* [list] -> a -> b */ 363 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 364 } 365 366 static void list_test_list_cut_position(struct kunit *test) 367 { 368 struct list_head entries[3], *cur; 369 LIST_HEAD(list1); 370 LIST_HEAD(list2); 371 int i = 0; 372 373 list_add_tail(&entries[0], &list1); 374 list_add_tail(&entries[1], &list1); 375 list_add_tail(&entries[2], &list1); 376 377 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 378 list_cut_position(&list2, &list1, &entries[1]); 379 /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */ 380 381 list_for_each(cur, &list2) { 382 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 383 i++; 384 } 385 386 KUNIT_EXPECT_EQ(test, i, 2); 387 388 list_for_each(cur, &list1) { 389 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 390 i++; 391 } 392 } 393 394 static void list_test_list_cut_before(struct kunit *test) 395 { 396 struct list_head entries[3], *cur; 397 LIST_HEAD(list1); 398 LIST_HEAD(list2); 399 int i = 0; 400 401 list_add_tail(&entries[0], &list1); 402 list_add_tail(&entries[1], &list1); 403 list_add_tail(&entries[2], &list1); 404 405 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 406 list_cut_before(&list2, &list1, &entries[1]); 407 /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */ 408 409 list_for_each(cur, &list2) { 410 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 411 i++; 412 } 413 414 KUNIT_EXPECT_EQ(test, i, 1); 415 416 list_for_each(cur, &list1) { 417 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 418 i++; 419 } 420 } 421 422 static void list_test_list_splice(struct kunit *test) 423 { 424 struct list_head entries[5], *cur; 425 LIST_HEAD(list1); 426 LIST_HEAD(list2); 427 int i = 0; 428 429 list_add_tail(&entries[0], &list1); 430 list_add_tail(&entries[1], &list1); 431 list_add_tail(&entries[2], &list2); 432 list_add_tail(&entries[3], &list2); 433 list_add_tail(&entries[4], &list1); 434 435 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 436 list_splice(&list2, &entries[1]); 437 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 438 439 list_for_each(cur, &list1) { 440 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 441 i++; 442 } 443 444 KUNIT_EXPECT_EQ(test, i, 5); 445 } 446 447 static void list_test_list_splice_tail(struct kunit *test) 448 { 449 struct list_head entries[5], *cur; 450 LIST_HEAD(list1); 451 LIST_HEAD(list2); 452 int i = 0; 453 454 list_add_tail(&entries[0], &list1); 455 list_add_tail(&entries[1], &list1); 456 list_add_tail(&entries[2], &list2); 457 list_add_tail(&entries[3], &list2); 458 list_add_tail(&entries[4], &list1); 459 460 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 461 list_splice_tail(&list2, &entries[4]); 462 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 463 464 list_for_each(cur, &list1) { 465 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 466 i++; 467 } 468 469 KUNIT_EXPECT_EQ(test, i, 5); 470 } 471 472 static void list_test_list_splice_init(struct kunit *test) 473 { 474 struct list_head entries[5], *cur; 475 LIST_HEAD(list1); 476 LIST_HEAD(list2); 477 int i = 0; 478 479 list_add_tail(&entries[0], &list1); 480 list_add_tail(&entries[1], &list1); 481 list_add_tail(&entries[2], &list2); 482 list_add_tail(&entries[3], &list2); 483 list_add_tail(&entries[4], &list1); 484 485 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 486 list_splice_init(&list2, &entries[1]); 487 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 488 489 list_for_each(cur, &list1) { 490 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 491 i++; 492 } 493 494 KUNIT_EXPECT_EQ(test, i, 5); 495 496 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 497 } 498 499 static void list_test_list_splice_tail_init(struct kunit *test) 500 { 501 struct list_head entries[5], *cur; 502 LIST_HEAD(list1); 503 LIST_HEAD(list2); 504 int i = 0; 505 506 list_add_tail(&entries[0], &list1); 507 list_add_tail(&entries[1], &list1); 508 list_add_tail(&entries[2], &list2); 509 list_add_tail(&entries[3], &list2); 510 list_add_tail(&entries[4], &list1); 511 512 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 513 list_splice_tail_init(&list2, &entries[4]); 514 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 515 516 list_for_each(cur, &list1) { 517 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 518 i++; 519 } 520 521 KUNIT_EXPECT_EQ(test, i, 5); 522 523 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 524 } 525 526 static void list_test_list_entry(struct kunit *test) 527 { 528 struct list_test_struct test_struct; 529 530 KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list), 531 struct list_test_struct, list)); 532 } 533 534 static void list_test_list_first_entry(struct kunit *test) 535 { 536 struct list_test_struct test_struct1, test_struct2; 537 LIST_HEAD(list); 538 539 list_add_tail(&test_struct1.list, &list); 540 list_add_tail(&test_struct2.list, &list); 541 542 543 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list, 544 struct list_test_struct, list)); 545 } 546 547 static void list_test_list_last_entry(struct kunit *test) 548 { 549 struct list_test_struct test_struct1, test_struct2; 550 LIST_HEAD(list); 551 552 list_add_tail(&test_struct1.list, &list); 553 list_add_tail(&test_struct2.list, &list); 554 555 556 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list, 557 struct list_test_struct, list)); 558 } 559 560 static void list_test_list_first_entry_or_null(struct kunit *test) 561 { 562 struct list_test_struct test_struct1, test_struct2; 563 LIST_HEAD(list); 564 565 KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list, 566 struct list_test_struct, list)); 567 568 list_add_tail(&test_struct1.list, &list); 569 list_add_tail(&test_struct2.list, &list); 570 571 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, 572 list_first_entry_or_null(&list, 573 struct list_test_struct, list)); 574 } 575 576 static void list_test_list_next_entry(struct kunit *test) 577 { 578 struct list_test_struct test_struct1, test_struct2; 579 LIST_HEAD(list); 580 581 list_add_tail(&test_struct1.list, &list); 582 list_add_tail(&test_struct2.list, &list); 583 584 585 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1, 586 list)); 587 } 588 589 static void list_test_list_prev_entry(struct kunit *test) 590 { 591 struct list_test_struct test_struct1, test_struct2; 592 LIST_HEAD(list); 593 594 list_add_tail(&test_struct1.list, &list); 595 list_add_tail(&test_struct2.list, &list); 596 597 598 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2, 599 list)); 600 } 601 602 static void list_test_list_for_each(struct kunit *test) 603 { 604 struct list_head entries[3], *cur; 605 LIST_HEAD(list); 606 int i = 0; 607 608 list_add_tail(&entries[0], &list); 609 list_add_tail(&entries[1], &list); 610 list_add_tail(&entries[2], &list); 611 612 list_for_each(cur, &list) { 613 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 614 i++; 615 } 616 617 KUNIT_EXPECT_EQ(test, i, 3); 618 } 619 620 static void list_test_list_for_each_prev(struct kunit *test) 621 { 622 struct list_head entries[3], *cur; 623 LIST_HEAD(list); 624 int i = 2; 625 626 list_add_tail(&entries[0], &list); 627 list_add_tail(&entries[1], &list); 628 list_add_tail(&entries[2], &list); 629 630 list_for_each_prev(cur, &list) { 631 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 632 i--; 633 } 634 635 KUNIT_EXPECT_EQ(test, i, -1); 636 } 637 638 static void list_test_list_for_each_safe(struct kunit *test) 639 { 640 struct list_head entries[3], *cur, *n; 641 LIST_HEAD(list); 642 int i = 0; 643 644 645 list_add_tail(&entries[0], &list); 646 list_add_tail(&entries[1], &list); 647 list_add_tail(&entries[2], &list); 648 649 list_for_each_safe(cur, n, &list) { 650 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 651 list_del(&entries[i]); 652 i++; 653 } 654 655 KUNIT_EXPECT_EQ(test, i, 3); 656 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 657 } 658 659 static void list_test_list_for_each_prev_safe(struct kunit *test) 660 { 661 struct list_head entries[3], *cur, *n; 662 LIST_HEAD(list); 663 int i = 2; 664 665 list_add_tail(&entries[0], &list); 666 list_add_tail(&entries[1], &list); 667 list_add_tail(&entries[2], &list); 668 669 list_for_each_prev_safe(cur, n, &list) { 670 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 671 list_del(&entries[i]); 672 i--; 673 } 674 675 KUNIT_EXPECT_EQ(test, i, -1); 676 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 677 } 678 679 static void list_test_list_for_each_entry(struct kunit *test) 680 { 681 struct list_test_struct entries[5], *cur; 682 LIST_HEAD(list); 683 int i = 0; 684 685 for (i = 0; i < 5; ++i) { 686 entries[i].data = i; 687 list_add_tail(&entries[i].list, &list); 688 } 689 690 i = 0; 691 692 list_for_each_entry(cur, &list, list) { 693 KUNIT_EXPECT_EQ(test, cur->data, i); 694 i++; 695 } 696 697 KUNIT_EXPECT_EQ(test, i, 5); 698 } 699 700 static void list_test_list_for_each_entry_reverse(struct kunit *test) 701 { 702 struct list_test_struct entries[5], *cur; 703 LIST_HEAD(list); 704 int i = 0; 705 706 for (i = 0; i < 5; ++i) { 707 entries[i].data = i; 708 list_add_tail(&entries[i].list, &list); 709 } 710 711 i = 4; 712 713 list_for_each_entry_reverse(cur, &list, list) { 714 KUNIT_EXPECT_EQ(test, cur->data, i); 715 i--; 716 } 717 718 KUNIT_EXPECT_EQ(test, i, -1); 719 } 720 721 static struct kunit_case list_test_cases[] = { 722 KUNIT_CASE(list_test_list_init), 723 KUNIT_CASE(list_test_list_add), 724 KUNIT_CASE(list_test_list_add_tail), 725 KUNIT_CASE(list_test_list_del), 726 KUNIT_CASE(list_test_list_replace), 727 KUNIT_CASE(list_test_list_replace_init), 728 KUNIT_CASE(list_test_list_swap), 729 KUNIT_CASE(list_test_list_del_init), 730 KUNIT_CASE(list_test_list_del_init_careful), 731 KUNIT_CASE(list_test_list_move), 732 KUNIT_CASE(list_test_list_move_tail), 733 KUNIT_CASE(list_test_list_bulk_move_tail), 734 KUNIT_CASE(list_test_list_is_first), 735 KUNIT_CASE(list_test_list_is_last), 736 KUNIT_CASE(list_test_list_empty), 737 KUNIT_CASE(list_test_list_empty_careful), 738 KUNIT_CASE(list_test_list_rotate_left), 739 KUNIT_CASE(list_test_list_rotate_to_front), 740 KUNIT_CASE(list_test_list_is_singular), 741 KUNIT_CASE(list_test_list_cut_position), 742 KUNIT_CASE(list_test_list_cut_before), 743 KUNIT_CASE(list_test_list_splice), 744 KUNIT_CASE(list_test_list_splice_tail), 745 KUNIT_CASE(list_test_list_splice_init), 746 KUNIT_CASE(list_test_list_splice_tail_init), 747 KUNIT_CASE(list_test_list_entry), 748 KUNIT_CASE(list_test_list_first_entry), 749 KUNIT_CASE(list_test_list_last_entry), 750 KUNIT_CASE(list_test_list_first_entry_or_null), 751 KUNIT_CASE(list_test_list_next_entry), 752 KUNIT_CASE(list_test_list_prev_entry), 753 KUNIT_CASE(list_test_list_for_each), 754 KUNIT_CASE(list_test_list_for_each_prev), 755 KUNIT_CASE(list_test_list_for_each_safe), 756 KUNIT_CASE(list_test_list_for_each_prev_safe), 757 KUNIT_CASE(list_test_list_for_each_entry), 758 KUNIT_CASE(list_test_list_for_each_entry_reverse), 759 {}, 760 }; 761 762 static struct kunit_suite list_test_module = { 763 .name = "list-kunit-test", 764 .test_cases = list_test_cases, 765 }; 766 767 kunit_test_suites(&list_test_module); 768 769 MODULE_LICENSE("GPL v2"); 770