@ohos-ports/bare-buffer 3.7.1-beta.0

package/deps/libutf/test/utf32/string-substring.c

@@ -0,0 +1,93 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  static const utf32_t hello_world[] = {'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0};
+
+  {
+    static const utf32_t expected[] = {'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 0};
+
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    utf32_string_view_t view = utf32_string_substring(&string, 2, 10);
+
+    assert(view.len == 8);
+    assert(utf32_string_view_compare_literal(view, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&string);
+  }
+
+  // An end of (size_t) -1, or one past the length, runs to the end of the
+  // string, and a start past the end gives an empty view.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_substring(&string, 6, (size_t) -1).len == 5);
+    assert(utf32_string_substring(&string, 6, 100).len == 5);
+    assert(utf32_string_substring(&string, 100, 100).len == 0);
+    assert(utf32_string_substring(&string, 8, 4).len == 0);
+
+    utf32_string_destroy(&string);
+  }
+
+  // Copying a substring out gives a string holding just those code points.
+  {
+    static const utf32_t expected[] = {'w', 'o', 'r', 'l', 'd', 0};
+
+    utf32_string_t string, copy;
+    utf32_string_init(&string);
+    utf32_string_init(&copy);
+
+    e = utf32_string_append_literal(&string, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_substring_copy(&string, 6, (size_t) -1, &copy);
+    assert(e == 0);
+    assert(copy.len == 5);
+    assert(utf32_string_compare_literal(&copy, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&copy);
+    utf32_string_destroy(&string);
+  }
+
+  // A copy into a string that has already outgrown its inline buffer reuses that
+  // allocation rather than leaking it.
+  {
+    utf32_string_t string, copy;
+    utf32_string_init(&string);
+    utf32_string_init(&copy);
+
+    e = utf32_string_append_literal(&string, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_reserve(&copy, UTF32_STRING_INLINE_CAPACITY * 8);
+    assert(e == 0);
+    assert(copy.data != copy.buf);
+
+    e = utf32_string_view_substring_copy(utf32_string_view(&string), 0, 5, &copy);
+    assert(e == 0);
+    assert(copy.len == 5);
+
+    // Still on the allocation reserved above. Were the result initialized here
+    // instead, this would have been dropped back to the inline buffer and the
+    // allocation leaked.
+    assert(copy.data != copy.buf);
+
+    utf32_string_destroy(&copy);
+    utf32_string_destroy(&string);
+  }
+}

package/deps/libutf/test/utf8/latin1-convert.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+#define test_convert(string, len, expected, written) \
+  { \
+    latin1_t result[len]; \
+    assert(utf8_convert_to_latin1((utf8_t *) string, len, result) == written); \
+    assert(memcmp(expected, result, written) == 0); \
+  }
+
+int
+main() {
+  // ASCII character 'A'
+  test_convert("\x41", 1, "\x41", 1);
+
+  // ø Character
+  test_convert("\xc3\xb8", 2, "\xf8", 1);
+
+  // Ending with an invalid character 'AAAД'
+  test_convert("\x41\x41\x41\xd0\x94", 4, "", 0);
+}

package/deps/libutf/test/utf8/string-append.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  utf8_string_t string;
+  utf8_string_init(&string);
+
+  e = utf8_string_append_literal(&string, (utf8_t *) "hello", -1);
+  assert(e == 0);
+
+  e = utf8_string_append_literal(&string, (utf8_t *) " world", -1);
+  assert(e == 0);
+
+  assert(memcmp(string.data, "hello world", string.len) == 0);
+
+  utf8_string_destroy(&string);
+}

package/deps/libutf/test/utf8/string-compare.c

@@ -0,0 +1,67 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  // Two empty strings are equal, and neither is compared over any bytes at all.
+  {
+    utf8_string_t a, b;
+    utf8_string_init(&a);
+    utf8_string_init(&b);
+
+    assert(utf8_string_compare(&a, &b) == 0);
+
+    utf8_string_view_t empty = utf8_string_view_init((const utf8_t *) "", 0);
+
+    assert(utf8_string_view_compare(empty, empty) == 0);
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "", 0) == 0);
+    assert(utf8_string_view_compare_literal(empty, (utf8_t *) "", 0) == 0);
+
+    utf8_string_destroy(&a);
+    utf8_string_destroy(&b);
+  }
+
+  // Ordering follows the bytes, with the shorter of two strings that share a
+  // prefix coming first.
+  {
+    utf8_string_t a;
+    utf8_string_init(&a);
+
+    e = utf8_string_append_literal(&a, (utf8_t *) "banana", -1);
+    assert(e == 0);
+
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "banana", -1) == 0);
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "banan", -1) > 0);
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "bananas", -1) < 0);
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "apple", -1) > 0);
+    assert(utf8_string_compare_literal(&a, (utf8_t *) "cherry", -1) < 0);
+
+    utf8_string_destroy(&a);
+  }
+
+  // A null byte is compared like any other byte, rather than ending the
+  // comparison as it would were these C strings.
+  {
+    utf8_string_view_t a = utf8_string_view_init((const utf8_t *) "a\0b", 3);
+    utf8_string_view_t b = utf8_string_view_init((const utf8_t *) "a\0c", 3);
+    utf8_string_view_t c = utf8_string_view_init((const utf8_t *) "a\0b", 3);
+
+    assert(utf8_string_view_compare(a, b) < 0);
+    assert(utf8_string_view_compare(b, a) > 0);
+    assert(utf8_string_view_compare(a, c) == 0);
+
+    // The bytes past a null byte also tell apart strings of unequal length.
+    utf8_string_view_t d = utf8_string_view_init((const utf8_t *) "a\0", 2);
+
+    assert(utf8_string_view_compare(d, a) < 0);
+    assert(utf8_string_view_compare(a, d) > 0);
+
+    assert(utf8_string_view_compare_literal(a, (utf8_t *) "a\0b", 3) == 0);
+    assert(utf8_string_view_compare_literal(a, (utf8_t *) "a\0c", 3) < 0);
+  }
+}

package/deps/libutf/test/utf8/string-erase.c

@@ -0,0 +1,75 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  // Plain erase in the middle.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello world", -1);
+    assert(e == 0);
+
+    e = utf8_string_erase(&s, 5, 6);
+    assert(e == 0);
+    assert(s.len == 5);
+    assert(memcmp(s.data, "hello", 5) == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Erase with len > string->len - pos must clamp.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_erase(&s, 2, 100);
+    assert(e == 0);
+    assert(s.len == 2);
+    assert(memcmp(s.data, "he", 2) == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Erase with pos + len overflowing size_t must also clamp.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_erase(&s, 1, SIZE_MAX);
+    assert(e == 0);
+    assert(s.len == 1);
+    assert(memcmp(s.data, "h", 1) == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Erase with pos > string->len is an error.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_erase(&s, 10, 1);
+    assert(e == -1);
+    assert(s.len == 5);
+
+    utf8_string_destroy(&s);
+  }
+}

package/deps/libutf/test/utf8/string-index.c

@@ -0,0 +1,99 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  // Empty string with pos = 0 or pos = (size_t) -1 must return not-found rather
+  // than search over a length of SIZE_MAX.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    assert(utf8_string_index_of_character(&s, 0, 'a') == (size_t) -1);
+    assert(utf8_string_index_of_character(&s, (size_t) -1, 'a') == (size_t) -1);
+
+    utf8_string_view_t view = utf8_string_view_init((const utf8_t *) "", 0);
+    assert(utf8_string_view_index_of_character(view, 0, 'a') == (size_t) -1);
+    assert(utf8_string_view_index_of_character(view, (size_t) -1, 'a') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Search from the start and find the first match.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "banana", -1);
+    assert(e == 0);
+
+    assert(utf8_string_index_of_character(&s, 0, 'b') == 0);
+    assert(utf8_string_index_of_character(&s, 0, 'a') == 1);
+    assert(utf8_string_index_of_character(&s, 0, 'n') == 2);
+
+    // Searching from a later position skips the earlier matches.
+    assert(utf8_string_index_of_character(&s, 1, 'a') == 1);
+    assert(utf8_string_index_of_character(&s, 2, 'a') == 3);
+    assert(utf8_string_index_of_character(&s, 4, 'a') == 5);
+    assert(utf8_string_index_of_character(&s, 5, 'n') == (size_t) -1);
+
+    utf8_string_view_t view = utf8_string_view(&s);
+
+    assert(utf8_string_view_index_of_character(view, 0, 'b') == 0);
+    assert(utf8_string_view_index_of_character(view, 2, 'a') == 3);
+    assert(utf8_string_view_index_of_character(view, 5, 'n') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+
+  // A search with no match returns not-found.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "abc", -1);
+    assert(e == 0);
+
+    assert(utf8_string_index_of_character(&s, 0, 'z') == (size_t) -1);
+
+    // pos at or past the end returns not-found.
+    assert(utf8_string_index_of_character(&s, 3, 'a') == (size_t) -1);
+    assert(utf8_string_index_of_character(&s, 100, 'a') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+
+  // A null byte is a byte like any other, both to search for and to search past.
+  {
+    utf8_string_view_t view = utf8_string_view_init((const utf8_t *) "a\0b", 3);
+
+    assert(utf8_string_view_index_of_character(view, 0, '\0') == 1);
+    assert(utf8_string_view_index_of_character(view, 0, 'b') == 2);
+  }
+
+  // A search over a stretch long enough to be done more than a byte at a time
+  // finds a match at either end of it.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    for (size_t i = 0; i < 100; i++) {
+      e = utf8_string_append_character(&s, 'a');
+      assert(e == 0);
+    }
+
+    e = utf8_string_append_character(&s, 'z');
+    assert(e == 0);
+
+    assert(utf8_string_index_of_character(&s, 0, 'z') == 100);
+    assert(utf8_string_index_of_character(&s, 1, 'a') == 1);
+    assert(utf8_string_index_of_character(&s, 0, 'y') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+}

package/deps/libutf/test/utf8/string-last-index.c

@@ -0,0 +1,68 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  // Empty string with pos = (size_t) -1 must return not-found instead of
+  // reading data[SIZE_MAX].
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    assert(utf8_string_last_index_of_character(&s, (size_t) -1, 'a') == (size_t) -1);
+
+    utf8_string_view_t view = utf8_string_view_init((const utf8_t *) "", 0);
+    assert(utf8_string_view_last_index_of_character(view, (size_t) -1, 'a') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Search from the end and find a match.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "banana", -1);
+    assert(e == 0);
+
+    assert(utf8_string_last_index_of_character(&s, (size_t) -1, 'a') == 5);
+    assert(utf8_string_last_index_of_character(&s, (size_t) -1, 'n') == 4);
+    assert(utf8_string_last_index_of_character(&s, (size_t) -1, 'b') == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Search with no match must terminate (loop must not run forever or read
+  // before the buffer).
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "abc", -1);
+    assert(e == 0);
+
+    assert(utf8_string_last_index_of_character(&s, (size_t) -1, 'z') == (size_t) -1);
+    assert(utf8_string_last_index_of_character(&s, 0, 'z') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+
+  // pos >= string->len returns not-found.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "abc", -1);
+    assert(e == 0);
+
+    assert(utf8_string_last_index_of_character(&s, 3, 'a') == (size_t) -1);
+    assert(utf8_string_last_index_of_character(&s, 100, 'a') == (size_t) -1);
+
+    utf8_string_destroy(&s);
+  }
+}

package/deps/libutf/test/utf8/string-prepend.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  utf8_string_t string;
+  utf8_string_init(&string);
+
+  e = utf8_string_prepend_literal(&string, (utf8_t *) " world", -1);
+  assert(e == 0);
+
+  e = utf8_string_prepend_literal(&string, (utf8_t *) "hello", -1);
+  assert(e == 0);
+
+  assert(memcmp(string.data, "hello world", string.len) == 0);
+
+  utf8_string_destroy(&string);
+}

package/deps/libutf/test/utf8/string-replace.c

@@ -0,0 +1,74 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  utf8_string_t string;
+  utf8_string_init(&string);
+
+  e = utf8_string_append_literal(&string, (utf8_t *) "hello world", -1);
+  assert(e == 0);
+
+  e = utf8_string_replace_literal(&string, 5, 1, (utf8_t *) " there ", -1);
+  assert(e == 0);
+
+  assert(memcmp(string.data, "hello there world", string.len) == 0);
+
+  utf8_string_destroy(&string);
+
+  // replace_character must clamp len to (string->len - pos) so memmove doesn't
+  // underflow size_t.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_replace_character(&s, 2, 100, 'X');
+    assert(e == 0);
+    assert(s.len == 3);
+    assert(memcmp(s.data, "heX", 3) == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // replace_character with pos + len overflowing size_t must also clamp.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_replace_character(&s, 1, SIZE_MAX, 'Y');
+    assert(e == 0);
+    assert(s.len == 2);
+    assert(memcmp(s.data, "hY", 2) == 0);
+
+    utf8_string_destroy(&s);
+  }
+
+  // replace_literal with pos + len overflowing size_t must also clamp.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello", -1);
+    assert(e == 0);
+
+    e = utf8_string_replace_literal(&s, 1, SIZE_MAX, (utf8_t *) "i!", 2);
+    assert(e == 0);
+    assert(s.len == 3);
+    assert(memcmp(s.data, "hi!", 3) == 0);
+
+    utf8_string_destroy(&s);
+  }
+}

package/deps/libutf/test/utf8/string-reserve.c

@@ -0,0 +1,51 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  // Normal reserve grows past the inline buffer.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_reserve(&s, 64);
+    assert(e == 0);
+    assert(s.data != s.buf);
+    assert(s.cap >= 64);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Reserve within the inline buffer is a no-op.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_reserve(&s, sizeof(s.buf));
+    assert(e == 0);
+    assert(s.data == s.buf);
+
+    utf8_string_destroy(&s);
+  }
+
+  // Reserve must reject sizes that would overflow the power-of-two rounding,
+  // rather than wrapping to cap = 0 and returning success.
+  {
+    utf8_string_t s;
+    utf8_string_init(&s);
+
+    e = utf8_string_reserve(&s, SIZE_MAX);
+    assert(e == -1);
+
+    e = utf8_string_reserve(&s, (SIZE_MAX >> 1) + 2);
+    assert(e == -1);
+
+    utf8_string_destroy(&s);
+  }
+}

package/deps/libutf/test/utf8/string-substring.c

@@ -0,0 +1,68 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  utf8_string_t string;
+  utf8_string_init(&string);
+
+  e = utf8_string_append_literal(&string, (utf8_t *) "hello world", -1);
+  assert(e == 0);
+
+  utf8_string_view_t view = utf8_string_substring(&string, 2, 8);
+
+  assert(memcmp(view.data, "llo worl", view.len) == 0);
+
+  utf8_string_destroy(&string);
+
+  // Copying a substring out gives a string holding just those bytes.
+  {
+    utf8_string_t s, copy;
+    utf8_string_init(&s);
+    utf8_string_init(&copy);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello world", -1);
+    assert(e == 0);
+
+    e = utf8_string_substring_copy(&s, 6, (size_t) -1, &copy);
+    assert(e == 0);
+    assert(copy.len == 5);
+    assert(memcmp(copy.data, "world", 5) == 0);
+
+    utf8_string_destroy(&copy);
+    utf8_string_destroy(&s);
+  }
+
+  // A copy into a string that has already outgrown its inline buffer reuses that
+  // allocation rather than leaking it.
+  {
+    utf8_string_t s, copy;
+    utf8_string_init(&s);
+    utf8_string_init(&copy);
+
+    e = utf8_string_append_literal(&s, (utf8_t *) "hello world", -1);
+    assert(e == 0);
+
+    e = utf8_string_reserve(&copy, sizeof(copy.buf) * 8);
+    assert(e == 0);
+    assert(copy.data != copy.buf);
+
+    e = utf8_string_view_substring_copy(utf8_string_view(&s), 0, 5, &copy);
+    assert(e == 0);
+    assert(copy.len == 5);
+    assert(memcmp(copy.data, "hello", 5) == 0);
+
+    // Still on the allocation reserved above. Were the result initialized here
+    // instead, this would have been dropped back to the inline buffer and the
+    // allocation leaked.
+    assert(copy.data != copy.buf);
+
+    utf8_string_destroy(&copy);
+    utf8_string_destroy(&s);
+  }
+}