list-test.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748
  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. #include <linux/list.h>
  10. struct list_test_struct {
  11. int data;
  12. struct list_head list;
  13. };
  14. static void list_test_list_init(struct kunit *test)
  15. {
  16. /* Test the different ways of initialising a list. */
  17. struct list_head list1 = LIST_HEAD_INIT(list1);
  18. struct list_head list2;
  19. LIST_HEAD(list3);
  20. struct list_head *list4;
  21. struct list_head *list5;
  22. INIT_LIST_HEAD(&list2);
  23. list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL);
  24. INIT_LIST_HEAD(list4);
  25. list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL);
  26. memset(list5, 0xFF, sizeof(*list5));
  27. INIT_LIST_HEAD(list5);
  28. /* list_empty_careful() checks both next and prev. */
  29. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1));
  30. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
  31. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3));
  32. KUNIT_EXPECT_TRUE(test, list_empty_careful(list4));
  33. KUNIT_EXPECT_TRUE(test, list_empty_careful(list5));
  34. kfree(list4);
  35. kfree(list5);
  36. }
  37. static void list_test_list_add(struct kunit *test)
  38. {
  39. struct list_head a, b;
  40. LIST_HEAD(list);
  41. list_add(&a, &list);
  42. list_add(&b, &list);
  43. /* should be [list] -> b -> a */
  44. KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
  45. KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
  46. KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
  47. }
  48. static void list_test_list_add_tail(struct kunit *test)
  49. {
  50. struct list_head a, b;
  51. LIST_HEAD(list);
  52. list_add_tail(&a, &list);
  53. list_add_tail(&b, &list);
  54. /* should be [list] -> a -> b */
  55. KUNIT_EXPECT_PTR_EQ(test, list.next, &a);
  56. KUNIT_EXPECT_PTR_EQ(test, a.prev, &list);
  57. KUNIT_EXPECT_PTR_EQ(test, a.next, &b);
  58. }
  59. static void list_test_list_del(struct kunit *test)
  60. {
  61. struct list_head a, b;
  62. LIST_HEAD(list);
  63. list_add_tail(&a, &list);
  64. list_add_tail(&b, &list);
  65. /* before: [list] -> a -> b */
  66. list_del(&a);
  67. /* now: [list] -> b */
  68. KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
  69. KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
  70. }
  71. static void list_test_list_replace(struct kunit *test)
  72. {
  73. struct list_head a_old, a_new, b;
  74. LIST_HEAD(list);
  75. list_add_tail(&a_old, &list);
  76. list_add_tail(&b, &list);
  77. /* before: [list] -> a_old -> b */
  78. list_replace(&a_old, &a_new);
  79. /* now: [list] -> a_new -> b */
  80. KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
  81. KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
  82. }
  83. static void list_test_list_replace_init(struct kunit *test)
  84. {
  85. struct list_head a_old, a_new, b;
  86. LIST_HEAD(list);
  87. list_add_tail(&a_old, &list);
  88. list_add_tail(&b, &list);
  89. /* before: [list] -> a_old -> b */
  90. list_replace_init(&a_old, &a_new);
  91. /* now: [list] -> a_new -> b */
  92. KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
  93. KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
  94. /* check a_old is empty (initialized) */
  95. KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old));
  96. }
  97. static void list_test_list_swap(struct kunit *test)
  98. {
  99. struct list_head a, b;
  100. LIST_HEAD(list);
  101. list_add_tail(&a, &list);
  102. list_add_tail(&b, &list);
  103. /* before: [list] -> a -> b */
  104. list_swap(&a, &b);
  105. /* after: [list] -> b -> a */
  106. KUNIT_EXPECT_PTR_EQ(test, &b, list.next);
  107. KUNIT_EXPECT_PTR_EQ(test, &a, list.prev);
  108. KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
  109. KUNIT_EXPECT_PTR_EQ(test, &list, b.prev);
  110. KUNIT_EXPECT_PTR_EQ(test, &list, a.next);
  111. KUNIT_EXPECT_PTR_EQ(test, &b, a.prev);
  112. }
  113. static void list_test_list_del_init(struct kunit *test)
  114. {
  115. struct list_head a, b;
  116. LIST_HEAD(list);
  117. list_add_tail(&a, &list);
  118. list_add_tail(&b, &list);
  119. /* before: [list] -> a -> b */
  120. list_del_init(&a);
  121. /* after: [list] -> b, a initialised */
  122. KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
  123. KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
  124. KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
  125. }
  126. static void list_test_list_move(struct kunit *test)
  127. {
  128. struct list_head a, b;
  129. LIST_HEAD(list1);
  130. LIST_HEAD(list2);
  131. list_add_tail(&a, &list1);
  132. list_add_tail(&b, &list2);
  133. /* before: [list1] -> a, [list2] -> b */
  134. list_move(&a, &list2);
  135. /* after: [list1] empty, [list2] -> a -> b */
  136. KUNIT_EXPECT_TRUE(test, list_empty(&list1));
  137. KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
  138. KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
  139. }
  140. static void list_test_list_move_tail(struct kunit *test)
  141. {
  142. struct list_head a, b;
  143. LIST_HEAD(list1);
  144. LIST_HEAD(list2);
  145. list_add_tail(&a, &list1);
  146. list_add_tail(&b, &list2);
  147. /* before: [list1] -> a, [list2] -> b */
  148. list_move_tail(&a, &list2);
  149. /* after: [list1] empty, [list2] -> b -> a */
  150. KUNIT_EXPECT_TRUE(test, list_empty(&list1));
  151. KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
  152. KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
  153. }
  154. static void list_test_list_bulk_move_tail(struct kunit *test)
  155. {
  156. struct list_head a, b, c, d, x, y;
  157. struct list_head *list1_values[] = { &x, &b, &c, &y };
  158. struct list_head *list2_values[] = { &a, &d };
  159. struct list_head *ptr;
  160. LIST_HEAD(list1);
  161. LIST_HEAD(list2);
  162. int i = 0;
  163. list_add_tail(&x, &list1);
  164. list_add_tail(&y, &list1);
  165. list_add_tail(&a, &list2);
  166. list_add_tail(&b, &list2);
  167. list_add_tail(&c, &list2);
  168. list_add_tail(&d, &list2);
  169. /* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */
  170. list_bulk_move_tail(&y, &b, &c);
  171. /* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */
  172. list_for_each(ptr, &list1) {
  173. KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
  174. i++;
  175. }
  176. KUNIT_EXPECT_EQ(test, i, 4);
  177. i = 0;
  178. list_for_each(ptr, &list2) {
  179. KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
  180. i++;
  181. }
  182. KUNIT_EXPECT_EQ(test, i, 2);
  183. }
  184. static void list_test_list_is_first(struct kunit *test)
  185. {
  186. struct list_head a, b;
  187. LIST_HEAD(list);
  188. list_add_tail(&a, &list);
  189. list_add_tail(&b, &list);
  190. KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
  191. KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
  192. }
  193. static void list_test_list_is_last(struct kunit *test)
  194. {
  195. struct list_head a, b;
  196. LIST_HEAD(list);
  197. list_add_tail(&a, &list);
  198. list_add_tail(&b, &list);
  199. KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
  200. KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
  201. }
  202. static void list_test_list_empty(struct kunit *test)
  203. {
  204. struct list_head a;
  205. LIST_HEAD(list1);
  206. LIST_HEAD(list2);
  207. list_add_tail(&a, &list1);
  208. KUNIT_EXPECT_FALSE(test, list_empty(&list1));
  209. KUNIT_EXPECT_TRUE(test, list_empty(&list2));
  210. }
  211. static void list_test_list_empty_careful(struct kunit *test)
  212. {
  213. /* This test doesn't check correctness under concurrent access */
  214. struct list_head a;
  215. LIST_HEAD(list1);
  216. LIST_HEAD(list2);
  217. list_add_tail(&a, &list1);
  218. KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
  219. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
  220. }
  221. static void list_test_list_rotate_left(struct kunit *test)
  222. {
  223. struct list_head a, b;
  224. LIST_HEAD(list);
  225. list_add_tail(&a, &list);
  226. list_add_tail(&b, &list);
  227. /* before: [list] -> a -> b */
  228. list_rotate_left(&list);
  229. /* after: [list] -> b -> a */
  230. KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
  231. KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
  232. KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
  233. }
  234. static void list_test_list_rotate_to_front(struct kunit *test)
  235. {
  236. struct list_head a, b, c, d;
  237. struct list_head *list_values[] = { &c, &d, &a, &b };
  238. struct list_head *ptr;
  239. LIST_HEAD(list);
  240. int i = 0;
  241. list_add_tail(&a, &list);
  242. list_add_tail(&b, &list);
  243. list_add_tail(&c, &list);
  244. list_add_tail(&d, &list);
  245. /* before: [list] -> a -> b -> c -> d */
  246. list_rotate_to_front(&c, &list);
  247. /* after: [list] -> c -> d -> a -> b */
  248. list_for_each(ptr, &list) {
  249. KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
  250. i++;
  251. }
  252. KUNIT_EXPECT_EQ(test, i, 4);
  253. }
  254. static void list_test_list_is_singular(struct kunit *test)
  255. {
  256. struct list_head a, b;
  257. LIST_HEAD(list);
  258. /* [list] empty */
  259. KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
  260. list_add_tail(&a, &list);
  261. /* [list] -> a */
  262. KUNIT_EXPECT_TRUE(test, list_is_singular(&list));
  263. list_add_tail(&b, &list);
  264. /* [list] -> a -> b */
  265. KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
  266. }
  267. static void list_test_list_cut_position(struct kunit *test)
  268. {
  269. struct list_head entries[3], *cur;
  270. LIST_HEAD(list1);
  271. LIST_HEAD(list2);
  272. int i = 0;
  273. list_add_tail(&entries[0], &list1);
  274. list_add_tail(&entries[1], &list1);
  275. list_add_tail(&entries[2], &list1);
  276. /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
  277. list_cut_position(&list2, &list1, &entries[1]);
  278. /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */
  279. list_for_each(cur, &list2) {
  280. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  281. i++;
  282. }
  283. KUNIT_EXPECT_EQ(test, i, 2);
  284. list_for_each(cur, &list1) {
  285. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  286. i++;
  287. }
  288. }
  289. static void list_test_list_cut_before(struct kunit *test)
  290. {
  291. struct list_head entries[3], *cur;
  292. LIST_HEAD(list1);
  293. LIST_HEAD(list2);
  294. int i = 0;
  295. list_add_tail(&entries[0], &list1);
  296. list_add_tail(&entries[1], &list1);
  297. list_add_tail(&entries[2], &list1);
  298. /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
  299. list_cut_before(&list2, &list1, &entries[1]);
  300. /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */
  301. list_for_each(cur, &list2) {
  302. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  303. i++;
  304. }
  305. KUNIT_EXPECT_EQ(test, i, 1);
  306. list_for_each(cur, &list1) {
  307. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  308. i++;
  309. }
  310. }
  311. static void list_test_list_splice(struct kunit *test)
  312. {
  313. struct list_head entries[5], *cur;
  314. LIST_HEAD(list1);
  315. LIST_HEAD(list2);
  316. int i = 0;
  317. list_add_tail(&entries[0], &list1);
  318. list_add_tail(&entries[1], &list1);
  319. list_add_tail(&entries[2], &list2);
  320. list_add_tail(&entries[3], &list2);
  321. list_add_tail(&entries[4], &list1);
  322. /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
  323. list_splice(&list2, &entries[1]);
  324. /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
  325. list_for_each(cur, &list1) {
  326. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  327. i++;
  328. }
  329. KUNIT_EXPECT_EQ(test, i, 5);
  330. }
  331. static void list_test_list_splice_tail(struct kunit *test)
  332. {
  333. struct list_head entries[5], *cur;
  334. LIST_HEAD(list1);
  335. LIST_HEAD(list2);
  336. int i = 0;
  337. list_add_tail(&entries[0], &list1);
  338. list_add_tail(&entries[1], &list1);
  339. list_add_tail(&entries[2], &list2);
  340. list_add_tail(&entries[3], &list2);
  341. list_add_tail(&entries[4], &list1);
  342. /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
  343. list_splice_tail(&list2, &entries[4]);
  344. /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
  345. list_for_each(cur, &list1) {
  346. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  347. i++;
  348. }
  349. KUNIT_EXPECT_EQ(test, i, 5);
  350. }
  351. static void list_test_list_splice_init(struct kunit *test)
  352. {
  353. struct list_head entries[5], *cur;
  354. LIST_HEAD(list1);
  355. LIST_HEAD(list2);
  356. int i = 0;
  357. list_add_tail(&entries[0], &list1);
  358. list_add_tail(&entries[1], &list1);
  359. list_add_tail(&entries[2], &list2);
  360. list_add_tail(&entries[3], &list2);
  361. list_add_tail(&entries[4], &list1);
  362. /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
  363. list_splice_init(&list2, &entries[1]);
  364. /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
  365. list_for_each(cur, &list1) {
  366. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  367. i++;
  368. }
  369. KUNIT_EXPECT_EQ(test, i, 5);
  370. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
  371. }
  372. static void list_test_list_splice_tail_init(struct kunit *test)
  373. {
  374. struct list_head entries[5], *cur;
  375. LIST_HEAD(list1);
  376. LIST_HEAD(list2);
  377. int i = 0;
  378. list_add_tail(&entries[0], &list1);
  379. list_add_tail(&entries[1], &list1);
  380. list_add_tail(&entries[2], &list2);
  381. list_add_tail(&entries[3], &list2);
  382. list_add_tail(&entries[4], &list1);
  383. /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
  384. list_splice_tail_init(&list2, &entries[4]);
  385. /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
  386. list_for_each(cur, &list1) {
  387. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  388. i++;
  389. }
  390. KUNIT_EXPECT_EQ(test, i, 5);
  391. KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
  392. }
  393. static void list_test_list_entry(struct kunit *test)
  394. {
  395. struct list_test_struct test_struct;
  396. KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
  397. struct list_test_struct, list));
  398. }
  399. static void list_test_list_first_entry(struct kunit *test)
  400. {
  401. struct list_test_struct test_struct1, test_struct2;
  402. LIST_HEAD(list);
  403. list_add_tail(&test_struct1.list, &list);
  404. list_add_tail(&test_struct2.list, &list);
  405. KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
  406. struct list_test_struct, list));
  407. }
  408. static void list_test_list_last_entry(struct kunit *test)
  409. {
  410. struct list_test_struct test_struct1, test_struct2;
  411. LIST_HEAD(list);
  412. list_add_tail(&test_struct1.list, &list);
  413. list_add_tail(&test_struct2.list, &list);
  414. KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
  415. struct list_test_struct, list));
  416. }
  417. static void list_test_list_first_entry_or_null(struct kunit *test)
  418. {
  419. struct list_test_struct test_struct1, test_struct2;
  420. LIST_HEAD(list);
  421. KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
  422. struct list_test_struct, list));
  423. list_add_tail(&test_struct1.list, &list);
  424. list_add_tail(&test_struct2.list, &list);
  425. KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
  426. list_first_entry_or_null(&list,
  427. struct list_test_struct, list));
  428. }
  429. static void list_test_list_next_entry(struct kunit *test)
  430. {
  431. struct list_test_struct test_struct1, test_struct2;
  432. LIST_HEAD(list);
  433. list_add_tail(&test_struct1.list, &list);
  434. list_add_tail(&test_struct2.list, &list);
  435. KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
  436. list));
  437. }
  438. static void list_test_list_prev_entry(struct kunit *test)
  439. {
  440. struct list_test_struct test_struct1, test_struct2;
  441. LIST_HEAD(list);
  442. list_add_tail(&test_struct1.list, &list);
  443. list_add_tail(&test_struct2.list, &list);
  444. KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
  445. list));
  446. }
  447. static void list_test_list_for_each(struct kunit *test)
  448. {
  449. struct list_head entries[3], *cur;
  450. LIST_HEAD(list);
  451. int i = 0;
  452. list_add_tail(&entries[0], &list);
  453. list_add_tail(&entries[1], &list);
  454. list_add_tail(&entries[2], &list);
  455. list_for_each(cur, &list) {
  456. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  457. i++;
  458. }
  459. KUNIT_EXPECT_EQ(test, i, 3);
  460. }
  461. static void list_test_list_for_each_prev(struct kunit *test)
  462. {
  463. struct list_head entries[3], *cur;
  464. LIST_HEAD(list);
  465. int i = 2;
  466. list_add_tail(&entries[0], &list);
  467. list_add_tail(&entries[1], &list);
  468. list_add_tail(&entries[2], &list);
  469. list_for_each_prev(cur, &list) {
  470. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  471. i--;
  472. }
  473. KUNIT_EXPECT_EQ(test, i, -1);
  474. }
  475. static void list_test_list_for_each_safe(struct kunit *test)
  476. {
  477. struct list_head entries[3], *cur, *n;
  478. LIST_HEAD(list);
  479. int i = 0;
  480. list_add_tail(&entries[0], &list);
  481. list_add_tail(&entries[1], &list);
  482. list_add_tail(&entries[2], &list);
  483. list_for_each_safe(cur, n, &list) {
  484. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  485. list_del(&entries[i]);
  486. i++;
  487. }
  488. KUNIT_EXPECT_EQ(test, i, 3);
  489. KUNIT_EXPECT_TRUE(test, list_empty(&list));
  490. }
  491. static void list_test_list_for_each_prev_safe(struct kunit *test)
  492. {
  493. struct list_head entries[3], *cur, *n;
  494. LIST_HEAD(list);
  495. int i = 2;
  496. list_add_tail(&entries[0], &list);
  497. list_add_tail(&entries[1], &list);
  498. list_add_tail(&entries[2], &list);
  499. list_for_each_prev_safe(cur, n, &list) {
  500. KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
  501. list_del(&entries[i]);
  502. i--;
  503. }
  504. KUNIT_EXPECT_EQ(test, i, -1);
  505. KUNIT_EXPECT_TRUE(test, list_empty(&list));
  506. }
  507. static void list_test_list_for_each_entry(struct kunit *test)
  508. {
  509. struct list_test_struct entries[5], *cur;
  510. LIST_HEAD(list);
  511. int i = 0;
  512. for (i = 0; i < 5; ++i) {
  513. entries[i].data = i;
  514. list_add_tail(&entries[i].list, &list);
  515. }
  516. i = 0;
  517. list_for_each_entry(cur, &list, list) {
  518. KUNIT_EXPECT_EQ(test, cur->data, i);
  519. i++;
  520. }
  521. KUNIT_EXPECT_EQ(test, i, 5);
  522. }
  523. static void list_test_list_for_each_entry_reverse(struct kunit *test)
  524. {
  525. struct list_test_struct entries[5], *cur;
  526. LIST_HEAD(list);
  527. int i = 0;
  528. for (i = 0; i < 5; ++i) {
  529. entries[i].data = i;
  530. list_add_tail(&entries[i].list, &list);
  531. }
  532. i = 4;
  533. list_for_each_entry_reverse(cur, &list, list) {
  534. KUNIT_EXPECT_EQ(test, cur->data, i);
  535. i--;
  536. }
  537. KUNIT_EXPECT_EQ(test, i, -1);
  538. }
  539. static struct kunit_case list_test_cases[] = {
  540. KUNIT_CASE(list_test_list_init),
  541. KUNIT_CASE(list_test_list_add),
  542. KUNIT_CASE(list_test_list_add_tail),
  543. KUNIT_CASE(list_test_list_del),
  544. KUNIT_CASE(list_test_list_replace),
  545. KUNIT_CASE(list_test_list_replace_init),
  546. KUNIT_CASE(list_test_list_swap),
  547. KUNIT_CASE(list_test_list_del_init),
  548. KUNIT_CASE(list_test_list_move),
  549. KUNIT_CASE(list_test_list_move_tail),
  550. KUNIT_CASE(list_test_list_bulk_move_tail),
  551. KUNIT_CASE(list_test_list_is_first),
  552. KUNIT_CASE(list_test_list_is_last),
  553. KUNIT_CASE(list_test_list_empty),
  554. KUNIT_CASE(list_test_list_empty_careful),
  555. KUNIT_CASE(list_test_list_rotate_left),
  556. KUNIT_CASE(list_test_list_rotate_to_front),
  557. KUNIT_CASE(list_test_list_is_singular),
  558. KUNIT_CASE(list_test_list_cut_position),
  559. KUNIT_CASE(list_test_list_cut_before),
  560. KUNIT_CASE(list_test_list_splice),
  561. KUNIT_CASE(list_test_list_splice_tail),
  562. KUNIT_CASE(list_test_list_splice_init),
  563. KUNIT_CASE(list_test_list_splice_tail_init),
  564. KUNIT_CASE(list_test_list_entry),
  565. KUNIT_CASE(list_test_list_first_entry),
  566. KUNIT_CASE(list_test_list_last_entry),
  567. KUNIT_CASE(list_test_list_first_entry_or_null),
  568. KUNIT_CASE(list_test_list_next_entry),
  569. KUNIT_CASE(list_test_list_prev_entry),
  570. KUNIT_CASE(list_test_list_for_each),
  571. KUNIT_CASE(list_test_list_for_each_prev),
  572. KUNIT_CASE(list_test_list_for_each_safe),
  573. KUNIT_CASE(list_test_list_for_each_prev_safe),
  574. KUNIT_CASE(list_test_list_for_each_entry),
  575. KUNIT_CASE(list_test_list_for_each_entry_reverse),
  576. {},
  577. };
  578. static struct kunit_suite list_test_module = {
  579. .name = "list-kunit-test",
  580. .test_cases = list_test_cases,
  581. };
  582. kunit_test_suites(&list_test_module);
  583. MODULE_LICENSE("GPL v2");