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_head(struct kunit *test) 258 { 259 struct list_head a, b, c; 260 261 /* Two lists: [a] -> b, [c] */ 262 INIT_LIST_HEAD(&a); 263 INIT_LIST_HEAD(&c); 264 list_add_tail(&b, &a); 265 266 KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a), 267 "Head element of same list"); 268 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b), 269 "Non-head element of same list"); 270 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c), 271 "Head element of different list"); 272 } 273 274 275 static void list_test_list_is_first(struct kunit *test) 276 { 277 struct list_head a, b; 278 LIST_HEAD(list); 279 280 list_add_tail(&a, &list); 281 list_add_tail(&b, &list); 282 283 KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list)); 284 KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list)); 285 } 286 287 static void list_test_list_is_last(struct kunit *test) 288 { 289 struct list_head a, b; 290 LIST_HEAD(list); 291 292 list_add_tail(&a, &list); 293 list_add_tail(&b, &list); 294 295 KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list)); 296 KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list)); 297 } 298 299 static void list_test_list_empty(struct kunit *test) 300 { 301 struct list_head a; 302 LIST_HEAD(list1); 303 LIST_HEAD(list2); 304 305 list_add_tail(&a, &list1); 306 307 KUNIT_EXPECT_FALSE(test, list_empty(&list1)); 308 KUNIT_EXPECT_TRUE(test, list_empty(&list2)); 309 } 310 311 static void list_test_list_empty_careful(struct kunit *test) 312 { 313 /* This test doesn't check correctness under concurrent access */ 314 struct list_head a; 315 LIST_HEAD(list1); 316 LIST_HEAD(list2); 317 318 list_add_tail(&a, &list1); 319 320 KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1)); 321 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 322 } 323 324 static void list_test_list_rotate_left(struct kunit *test) 325 { 326 struct list_head a, b; 327 LIST_HEAD(list); 328 329 list_add_tail(&a, &list); 330 list_add_tail(&b, &list); 331 332 /* before: [list] -> a -> b */ 333 list_rotate_left(&list); 334 /* after: [list] -> b -> a */ 335 336 KUNIT_EXPECT_PTR_EQ(test, list.next, &b); 337 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list); 338 KUNIT_EXPECT_PTR_EQ(test, b.next, &a); 339 } 340 341 static void list_test_list_rotate_to_front(struct kunit *test) 342 { 343 struct list_head a, b, c, d; 344 struct list_head *list_values[] = { &c, &d, &a, &b }; 345 struct list_head *ptr; 346 LIST_HEAD(list); 347 int i = 0; 348 349 list_add_tail(&a, &list); 350 list_add_tail(&b, &list); 351 list_add_tail(&c, &list); 352 list_add_tail(&d, &list); 353 354 /* before: [list] -> a -> b -> c -> d */ 355 list_rotate_to_front(&c, &list); 356 /* after: [list] -> c -> d -> a -> b */ 357 358 list_for_each(ptr, &list) { 359 KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]); 360 i++; 361 } 362 KUNIT_EXPECT_EQ(test, i, 4); 363 } 364 365 static void list_test_list_is_singular(struct kunit *test) 366 { 367 struct list_head a, b; 368 LIST_HEAD(list); 369 370 /* [list] empty */ 371 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 372 373 list_add_tail(&a, &list); 374 375 /* [list] -> a */ 376 KUNIT_EXPECT_TRUE(test, list_is_singular(&list)); 377 378 list_add_tail(&b, &list); 379 380 /* [list] -> a -> b */ 381 KUNIT_EXPECT_FALSE(test, list_is_singular(&list)); 382 } 383 384 static void list_test_list_cut_position(struct kunit *test) 385 { 386 struct list_head entries[3], *cur; 387 LIST_HEAD(list1); 388 LIST_HEAD(list2); 389 int i = 0; 390 391 list_add_tail(&entries[0], &list1); 392 list_add_tail(&entries[1], &list1); 393 list_add_tail(&entries[2], &list1); 394 395 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 396 list_cut_position(&list2, &list1, &entries[1]); 397 /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */ 398 399 list_for_each(cur, &list2) { 400 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 401 i++; 402 } 403 404 KUNIT_EXPECT_EQ(test, i, 2); 405 406 list_for_each(cur, &list1) { 407 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 408 i++; 409 } 410 } 411 412 static void list_test_list_cut_before(struct kunit *test) 413 { 414 struct list_head entries[3], *cur; 415 LIST_HEAD(list1); 416 LIST_HEAD(list2); 417 int i = 0; 418 419 list_add_tail(&entries[0], &list1); 420 list_add_tail(&entries[1], &list1); 421 list_add_tail(&entries[2], &list1); 422 423 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */ 424 list_cut_before(&list2, &list1, &entries[1]); 425 /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */ 426 427 list_for_each(cur, &list2) { 428 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 429 i++; 430 } 431 432 KUNIT_EXPECT_EQ(test, i, 1); 433 434 list_for_each(cur, &list1) { 435 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 436 i++; 437 } 438 } 439 440 static void list_test_list_splice(struct kunit *test) 441 { 442 struct list_head entries[5], *cur; 443 LIST_HEAD(list1); 444 LIST_HEAD(list2); 445 int i = 0; 446 447 list_add_tail(&entries[0], &list1); 448 list_add_tail(&entries[1], &list1); 449 list_add_tail(&entries[2], &list2); 450 list_add_tail(&entries[3], &list2); 451 list_add_tail(&entries[4], &list1); 452 453 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 454 list_splice(&list2, &entries[1]); 455 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 456 457 list_for_each(cur, &list1) { 458 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 459 i++; 460 } 461 462 KUNIT_EXPECT_EQ(test, i, 5); 463 } 464 465 static void list_test_list_splice_tail(struct kunit *test) 466 { 467 struct list_head entries[5], *cur; 468 LIST_HEAD(list1); 469 LIST_HEAD(list2); 470 int i = 0; 471 472 list_add_tail(&entries[0], &list1); 473 list_add_tail(&entries[1], &list1); 474 list_add_tail(&entries[2], &list2); 475 list_add_tail(&entries[3], &list2); 476 list_add_tail(&entries[4], &list1); 477 478 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 479 list_splice_tail(&list2, &entries[4]); 480 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */ 481 482 list_for_each(cur, &list1) { 483 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 484 i++; 485 } 486 487 KUNIT_EXPECT_EQ(test, i, 5); 488 } 489 490 static void list_test_list_splice_init(struct kunit *test) 491 { 492 struct list_head entries[5], *cur; 493 LIST_HEAD(list1); 494 LIST_HEAD(list2); 495 int i = 0; 496 497 list_add_tail(&entries[0], &list1); 498 list_add_tail(&entries[1], &list1); 499 list_add_tail(&entries[2], &list2); 500 list_add_tail(&entries[3], &list2); 501 list_add_tail(&entries[4], &list1); 502 503 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 504 list_splice_init(&list2, &entries[1]); 505 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 506 507 list_for_each(cur, &list1) { 508 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 509 i++; 510 } 511 512 KUNIT_EXPECT_EQ(test, i, 5); 513 514 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 515 } 516 517 static void list_test_list_splice_tail_init(struct kunit *test) 518 { 519 struct list_head entries[5], *cur; 520 LIST_HEAD(list1); 521 LIST_HEAD(list2); 522 int i = 0; 523 524 list_add_tail(&entries[0], &list1); 525 list_add_tail(&entries[1], &list1); 526 list_add_tail(&entries[2], &list2); 527 list_add_tail(&entries[3], &list2); 528 list_add_tail(&entries[4], &list1); 529 530 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */ 531 list_splice_tail_init(&list2, &entries[4]); 532 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */ 533 534 list_for_each(cur, &list1) { 535 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 536 i++; 537 } 538 539 KUNIT_EXPECT_EQ(test, i, 5); 540 541 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2)); 542 } 543 544 static void list_test_list_entry(struct kunit *test) 545 { 546 struct list_test_struct test_struct; 547 548 KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list), 549 struct list_test_struct, list)); 550 } 551 552 static void list_test_list_entry_is_head(struct kunit *test) 553 { 554 struct list_test_struct test_struct1, test_struct2, test_struct3; 555 556 INIT_LIST_HEAD(&test_struct1.list); 557 INIT_LIST_HEAD(&test_struct3.list); 558 559 list_add_tail(&test_struct2.list, &test_struct1.list); 560 561 KUNIT_EXPECT_TRUE_MSG(test, 562 list_entry_is_head((&test_struct1), &test_struct1.list, list), 563 "Head element of same list"); 564 KUNIT_EXPECT_FALSE_MSG(test, 565 list_entry_is_head((&test_struct2), &test_struct1.list, list), 566 "Non-head element of same list"); 567 KUNIT_EXPECT_FALSE_MSG(test, 568 list_entry_is_head((&test_struct3), &test_struct1.list, list), 569 "Head element of different list"); 570 } 571 572 static void list_test_list_first_entry(struct kunit *test) 573 { 574 struct list_test_struct test_struct1, test_struct2; 575 LIST_HEAD(list); 576 577 list_add_tail(&test_struct1.list, &list); 578 list_add_tail(&test_struct2.list, &list); 579 580 581 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list, 582 struct list_test_struct, list)); 583 } 584 585 static void list_test_list_last_entry(struct kunit *test) 586 { 587 struct list_test_struct test_struct1, test_struct2; 588 LIST_HEAD(list); 589 590 list_add_tail(&test_struct1.list, &list); 591 list_add_tail(&test_struct2.list, &list); 592 593 594 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list, 595 struct list_test_struct, list)); 596 } 597 598 static void list_test_list_first_entry_or_null(struct kunit *test) 599 { 600 struct list_test_struct test_struct1, test_struct2; 601 LIST_HEAD(list); 602 603 KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list, 604 struct list_test_struct, list)); 605 606 list_add_tail(&test_struct1.list, &list); 607 list_add_tail(&test_struct2.list, &list); 608 609 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, 610 list_first_entry_or_null(&list, 611 struct list_test_struct, list)); 612 } 613 614 static void list_test_list_next_entry(struct kunit *test) 615 { 616 struct list_test_struct test_struct1, test_struct2; 617 LIST_HEAD(list); 618 619 list_add_tail(&test_struct1.list, &list); 620 list_add_tail(&test_struct2.list, &list); 621 622 623 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1, 624 list)); 625 } 626 627 static void list_test_list_prev_entry(struct kunit *test) 628 { 629 struct list_test_struct test_struct1, test_struct2; 630 LIST_HEAD(list); 631 632 list_add_tail(&test_struct1.list, &list); 633 list_add_tail(&test_struct2.list, &list); 634 635 636 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2, 637 list)); 638 } 639 640 static void list_test_list_for_each(struct kunit *test) 641 { 642 struct list_head entries[3], *cur; 643 LIST_HEAD(list); 644 int i = 0; 645 646 list_add_tail(&entries[0], &list); 647 list_add_tail(&entries[1], &list); 648 list_add_tail(&entries[2], &list); 649 650 list_for_each(cur, &list) { 651 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 652 i++; 653 } 654 655 KUNIT_EXPECT_EQ(test, i, 3); 656 } 657 658 static void list_test_list_for_each_prev(struct kunit *test) 659 { 660 struct list_head entries[3], *cur; 661 LIST_HEAD(list); 662 int i = 2; 663 664 list_add_tail(&entries[0], &list); 665 list_add_tail(&entries[1], &list); 666 list_add_tail(&entries[2], &list); 667 668 list_for_each_prev(cur, &list) { 669 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 670 i--; 671 } 672 673 KUNIT_EXPECT_EQ(test, i, -1); 674 } 675 676 static void list_test_list_for_each_safe(struct kunit *test) 677 { 678 struct list_head entries[3], *cur, *n; 679 LIST_HEAD(list); 680 int i = 0; 681 682 683 list_add_tail(&entries[0], &list); 684 list_add_tail(&entries[1], &list); 685 list_add_tail(&entries[2], &list); 686 687 list_for_each_safe(cur, n, &list) { 688 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 689 list_del(&entries[i]); 690 i++; 691 } 692 693 KUNIT_EXPECT_EQ(test, i, 3); 694 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 695 } 696 697 static void list_test_list_for_each_prev_safe(struct kunit *test) 698 { 699 struct list_head entries[3], *cur, *n; 700 LIST_HEAD(list); 701 int i = 2; 702 703 list_add_tail(&entries[0], &list); 704 list_add_tail(&entries[1], &list); 705 list_add_tail(&entries[2], &list); 706 707 list_for_each_prev_safe(cur, n, &list) { 708 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]); 709 list_del(&entries[i]); 710 i--; 711 } 712 713 KUNIT_EXPECT_EQ(test, i, -1); 714 KUNIT_EXPECT_TRUE(test, list_empty(&list)); 715 } 716 717 static void list_test_list_for_each_entry(struct kunit *test) 718 { 719 struct list_test_struct entries[5], *cur; 720 LIST_HEAD(list); 721 int i = 0; 722 723 for (i = 0; i < 5; ++i) { 724 entries[i].data = i; 725 list_add_tail(&entries[i].list, &list); 726 } 727 728 i = 0; 729 730 list_for_each_entry(cur, &list, list) { 731 KUNIT_EXPECT_EQ(test, cur->data, i); 732 i++; 733 } 734 735 KUNIT_EXPECT_EQ(test, i, 5); 736 } 737 738 static void list_test_list_for_each_entry_reverse(struct kunit *test) 739 { 740 struct list_test_struct entries[5], *cur; 741 LIST_HEAD(list); 742 int i = 0; 743 744 for (i = 0; i < 5; ++i) { 745 entries[i].data = i; 746 list_add_tail(&entries[i].list, &list); 747 } 748 749 i = 4; 750 751 list_for_each_entry_reverse(cur, &list, list) { 752 KUNIT_EXPECT_EQ(test, cur->data, i); 753 i--; 754 } 755 756 KUNIT_EXPECT_EQ(test, i, -1); 757 } 758 759 static struct kunit_case list_test_cases[] = { 760 KUNIT_CASE(list_test_list_init), 761 KUNIT_CASE(list_test_list_add), 762 KUNIT_CASE(list_test_list_add_tail), 763 KUNIT_CASE(list_test_list_del), 764 KUNIT_CASE(list_test_list_replace), 765 KUNIT_CASE(list_test_list_replace_init), 766 KUNIT_CASE(list_test_list_swap), 767 KUNIT_CASE(list_test_list_del_init), 768 KUNIT_CASE(list_test_list_del_init_careful), 769 KUNIT_CASE(list_test_list_move), 770 KUNIT_CASE(list_test_list_move_tail), 771 KUNIT_CASE(list_test_list_bulk_move_tail), 772 KUNIT_CASE(list_test_list_is_head), 773 KUNIT_CASE(list_test_list_is_first), 774 KUNIT_CASE(list_test_list_is_last), 775 KUNIT_CASE(list_test_list_empty), 776 KUNIT_CASE(list_test_list_empty_careful), 777 KUNIT_CASE(list_test_list_rotate_left), 778 KUNIT_CASE(list_test_list_rotate_to_front), 779 KUNIT_CASE(list_test_list_is_singular), 780 KUNIT_CASE(list_test_list_cut_position), 781 KUNIT_CASE(list_test_list_cut_before), 782 KUNIT_CASE(list_test_list_splice), 783 KUNIT_CASE(list_test_list_splice_tail), 784 KUNIT_CASE(list_test_list_splice_init), 785 KUNIT_CASE(list_test_list_splice_tail_init), 786 KUNIT_CASE(list_test_list_entry), 787 KUNIT_CASE(list_test_list_entry_is_head), 788 KUNIT_CASE(list_test_list_first_entry), 789 KUNIT_CASE(list_test_list_last_entry), 790 KUNIT_CASE(list_test_list_first_entry_or_null), 791 KUNIT_CASE(list_test_list_next_entry), 792 KUNIT_CASE(list_test_list_prev_entry), 793 KUNIT_CASE(list_test_list_for_each), 794 KUNIT_CASE(list_test_list_for_each_prev), 795 KUNIT_CASE(list_test_list_for_each_safe), 796 KUNIT_CASE(list_test_list_for_each_prev_safe), 797 KUNIT_CASE(list_test_list_for_each_entry), 798 KUNIT_CASE(list_test_list_for_each_entry_reverse), 799 {}, 800 }; 801 802 static struct kunit_suite list_test_module = { 803 .name = "list-kunit-test", 804 .test_cases = list_test_cases, 805 }; 806 807 kunit_test_suites(&list_test_module); 808 809 MODULE_LICENSE("GPL v2"); 810