TestWchar.cpp 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. /*
  2. * Copyright (c) 2021, the SerenityOS developers
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibTest/TestCase.h>
  7. #include <string.h>
  8. #include <wchar.h>
  9. TEST_CASE(wcspbrk)
  10. {
  11. const wchar_t* input;
  12. wchar_t* ret;
  13. // Test empty haystack.
  14. ret = wcspbrk(L"", L"ab");
  15. EXPECT_EQ(ret, nullptr);
  16. // Test empty needle.
  17. ret = wcspbrk(L"ab", L"");
  18. EXPECT_EQ(ret, nullptr);
  19. // Test search for a single character.
  20. input = L"abcd";
  21. ret = wcspbrk(input, L"a");
  22. EXPECT_EQ(ret, input);
  23. // Test search for multiple characters, none matches.
  24. ret = wcspbrk(input, L"zxy");
  25. EXPECT_EQ(ret, nullptr);
  26. // Test search for multiple characters, last matches.
  27. ret = wcspbrk(input, L"zxyc");
  28. EXPECT_EQ(ret, input + 2);
  29. }
  30. TEST_CASE(wcsstr)
  31. {
  32. const wchar_t* input = L"abcde";
  33. wchar_t* ret;
  34. // Empty needle should return haystack.
  35. ret = wcsstr(input, L"");
  36. EXPECT_EQ(ret, input);
  37. // Test exact match.
  38. ret = wcsstr(input, input);
  39. EXPECT_EQ(ret, input);
  40. // Test match at string start.
  41. ret = wcsstr(input, L"ab");
  42. EXPECT_EQ(ret, input);
  43. // Test match at string end.
  44. ret = wcsstr(input, L"de");
  45. EXPECT_EQ(ret, input + 3);
  46. // Test no match.
  47. ret = wcsstr(input, L"z");
  48. EXPECT_EQ(ret, nullptr);
  49. // Test needle that is longer than the haystack.
  50. ret = wcsstr(input, L"abcdef");
  51. EXPECT_EQ(ret, nullptr);
  52. }
  53. TEST_CASE(wmemchr)
  54. {
  55. const wchar_t* input = L"abcde";
  56. wchar_t* ret;
  57. // Empty haystack returns nothing.
  58. ret = wmemchr(L"", L'c', 0);
  59. EXPECT_EQ(ret, nullptr);
  60. // Not included character returns nothing.
  61. ret = wmemchr(input, L'z', 5);
  62. EXPECT_EQ(ret, nullptr);
  63. // Match at string start.
  64. ret = wmemchr(input, L'a', 5);
  65. EXPECT_EQ(ret, input);
  66. // Match at string end.
  67. ret = wmemchr(input, L'e', 5);
  68. EXPECT_EQ(ret, input + 4);
  69. input = L"abcde\0fg";
  70. // Handle finding null characters.
  71. ret = wmemchr(input, L'\0', 8);
  72. EXPECT_EQ(ret, input + 5);
  73. // Don't stop at null characters.
  74. ret = wmemchr(input, L'f', 8);
  75. EXPECT_EQ(ret, input + 6);
  76. }
  77. TEST_CASE(wmemcpy)
  78. {
  79. const wchar_t* input = L"abc\0def";
  80. auto buf = static_cast<wchar_t*>(malloc(8 * sizeof(wchar_t)));
  81. if (!buf) {
  82. FAIL("Could not allocate space for copy target");
  83. return;
  84. }
  85. wchar_t* ret = wmemcpy(buf, input, 8);
  86. EXPECT_EQ(ret, buf);
  87. EXPECT_EQ(memcmp(buf, input, 8 * sizeof(wchar_t)), 0);
  88. }
  89. TEST_CASE(wmemset)
  90. {
  91. auto buf_length = 8;
  92. auto buf = static_cast<wchar_t*>(calloc(buf_length, sizeof(wchar_t)));
  93. if (!buf) {
  94. FAIL("Could not allocate memory for target buffer");
  95. return;
  96. }
  97. wchar_t* ret = wmemset(buf, L'\U0001f41e', buf_length - 1);
  98. EXPECT_EQ(ret, buf);
  99. for (int i = 0; i < buf_length - 1; i++) {
  100. EXPECT_EQ(buf[i], L'\U0001f41e');
  101. }
  102. EXPECT_EQ(buf[buf_length - 1], L'\0');
  103. free(buf);
  104. }
  105. TEST_CASE(wcscoll)
  106. {
  107. // Check if wcscoll is sorting correctly. At the moment we are doing raw char comparisons,
  108. // so it's digits, then uppercase letters, then lowercase letters.
  109. // Equalness between equal strings.
  110. EXPECT(wcscoll(L"", L"") == 0);
  111. EXPECT(wcscoll(L"0", L"0") == 0);
  112. // Shorter strings before longer strings.
  113. EXPECT(wcscoll(L"", L"0") < 0);
  114. EXPECT(wcscoll(L"0", L"") > 0);
  115. EXPECT(wcscoll(L"123", L"1234") < 0);
  116. EXPECT(wcscoll(L"1234", L"123") > 0);
  117. // Order within digits.
  118. EXPECT(wcscoll(L"0", L"9") < 0);
  119. EXPECT(wcscoll(L"9", L"0") > 0);
  120. // Digits before uppercase letters.
  121. EXPECT(wcscoll(L"9", L"A") < 0);
  122. EXPECT(wcscoll(L"A", L"9") > 0);
  123. // Order within uppercase letters.
  124. EXPECT(wcscoll(L"A", L"Z") < 0);
  125. EXPECT(wcscoll(L"Z", L"A") > 0);
  126. // Uppercase letters before lowercase letters.
  127. EXPECT(wcscoll(L"Z", L"a") < 0);
  128. EXPECT(wcscoll(L"a", L"Z") > 0);
  129. // Uppercase letters before lowercase letters.
  130. EXPECT(wcscoll(L"a", L"z") < 0);
  131. EXPECT(wcscoll(L"z", L"a") > 0);
  132. }