string.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2019 Heinrich Schuchardt <xypron.glpk@gmx.de>
  4. *
  5. * Unit tests for memory functions
  6. *
  7. * The architecture dependent implementations run through different lines of
  8. * code depending on the alignment and length of memory regions copied or set.
  9. * This has to be considered in testing.
  10. */
  11. #include <common.h>
  12. #include <command.h>
  13. #include <log.h>
  14. #include <test/lib.h>
  15. #include <test/test.h>
  16. #include <test/ut.h>
  17. /* Xor mask used for marking memory regions */
  18. #define MASK 0xA5
  19. /* Number of different alignment values */
  20. #define SWEEP 16
  21. /* Allow for copying up to 32 bytes */
  22. #define BUFLEN (SWEEP + 33)
  23. /**
  24. * init_buffer() - initialize buffer
  25. *
  26. * The buffer is filled with incrementing values xor'ed with the mask.
  27. *
  28. * @buf: buffer
  29. * @mask: xor mask
  30. */
  31. static void init_buffer(u8 buf[], u8 mask)
  32. {
  33. int i;
  34. for (i = 0; i < BUFLEN; ++i)
  35. buf[i] = i ^ mask;
  36. }
  37. /**
  38. * test_memset() - test result of memset()
  39. *
  40. * @uts: unit test state
  41. * @buf: buffer
  42. * @mask: value set by memset()
  43. * @offset: relative start of region changed by memset() in buffer
  44. * @len: length of region changed by memset()
  45. * Return: 0 = success, 1 = failure
  46. */
  47. static int test_memset(struct unit_test_state *uts, u8 buf[], u8 mask,
  48. int offset, int len)
  49. {
  50. int i;
  51. for (i = 0; i < BUFLEN; ++i) {
  52. if (i < offset || i >= offset + len) {
  53. ut_asserteq(i, buf[i]);
  54. } else {
  55. ut_asserteq(mask, buf[i]);
  56. }
  57. }
  58. return 0;
  59. }
  60. /**
  61. * lib_memset() - unit test for memset()
  62. *
  63. * Test memset() with varied alignment and length of the changed buffer.
  64. *
  65. * @uts: unit test state
  66. * Return: 0 = success, 1 = failure
  67. */
  68. static int lib_memset(struct unit_test_state *uts)
  69. {
  70. u8 buf[BUFLEN];
  71. int offset, len;
  72. void *ptr;
  73. for (offset = 0; offset <= SWEEP; ++offset) {
  74. for (len = 1; len < BUFLEN - SWEEP; ++len) {
  75. init_buffer(buf, 0);
  76. ptr = memset(buf + offset, MASK, len);
  77. ut_asserteq_ptr(buf + offset, (u8 *)ptr);
  78. if (test_memset(uts, buf, MASK, offset, len)) {
  79. debug("%s: failure %d, %d\n",
  80. __func__, offset, len);
  81. return CMD_RET_FAILURE;
  82. }
  83. }
  84. }
  85. return 0;
  86. }
  87. LIB_TEST(lib_memset, 0);
  88. /**
  89. * test_memmove() - test result of memcpy() or memmove()
  90. *
  91. * @uts: unit test state
  92. * @buf: buffer
  93. * @mask: xor mask used to initialize source buffer
  94. * @offset1: relative start of copied region in source buffer
  95. * @offset2: relative start of copied region in destination buffer
  96. * @len: length of region changed by memset()
  97. * Return: 0 = success, 1 = failure
  98. */
  99. static int test_memmove(struct unit_test_state *uts, u8 buf[], u8 mask,
  100. int offset1, int offset2, int len)
  101. {
  102. int i;
  103. for (i = 0; i < BUFLEN; ++i) {
  104. if (i < offset2 || i >= offset2 + len) {
  105. ut_asserteq(i, buf[i]);
  106. } else {
  107. ut_asserteq((i + offset1 - offset2) ^ mask, buf[i]);
  108. }
  109. }
  110. return 0;
  111. }
  112. /**
  113. * lib_memcpy() - unit test for memcpy()
  114. *
  115. * Test memcpy() with varied alignment and length of the copied buffer.
  116. *
  117. * @uts: unit test state
  118. * Return: 0 = success, 1 = failure
  119. */
  120. static int lib_memcpy(struct unit_test_state *uts)
  121. {
  122. u8 buf1[BUFLEN];
  123. u8 buf2[BUFLEN];
  124. int offset1, offset2, len;
  125. void *ptr;
  126. init_buffer(buf1, MASK);
  127. for (offset1 = 0; offset1 <= SWEEP; ++offset1) {
  128. for (offset2 = 0; offset2 <= SWEEP; ++offset2) {
  129. for (len = 1; len < BUFLEN - SWEEP; ++len) {
  130. init_buffer(buf2, 0);
  131. ptr = memcpy(buf2 + offset2, buf1 + offset1,
  132. len);
  133. ut_asserteq_ptr(buf2 + offset2, (u8 *)ptr);
  134. if (test_memmove(uts, buf2, MASK, offset1,
  135. offset2, len)) {
  136. debug("%s: failure %d, %d, %d\n",
  137. __func__, offset1, offset2, len);
  138. return CMD_RET_FAILURE;
  139. }
  140. }
  141. }
  142. }
  143. return 0;
  144. }
  145. LIB_TEST(lib_memcpy, 0);
  146. /**
  147. * lib_memmove() - unit test for memmove()
  148. *
  149. * Test memmove() with varied alignment and length of the copied buffer.
  150. *
  151. * @uts: unit test state
  152. * Return: 0 = success, 1 = failure
  153. */
  154. static int lib_memmove(struct unit_test_state *uts)
  155. {
  156. u8 buf[BUFLEN];
  157. int offset1, offset2, len;
  158. void *ptr;
  159. for (offset1 = 0; offset1 <= SWEEP; ++offset1) {
  160. for (offset2 = 0; offset2 <= SWEEP; ++offset2) {
  161. for (len = 1; len < BUFLEN - SWEEP; ++len) {
  162. init_buffer(buf, 0);
  163. ptr = memmove(buf + offset2, buf + offset1,
  164. len);
  165. ut_asserteq_ptr(buf + offset2, (u8 *)ptr);
  166. if (test_memmove(uts, buf, 0, offset1, offset2,
  167. len)) {
  168. debug("%s: failure %d, %d, %d\n",
  169. __func__, offset1, offset2, len);
  170. return CMD_RET_FAILURE;
  171. }
  172. }
  173. }
  174. }
  175. return 0;
  176. }
  177. LIB_TEST(lib_memmove, 0);