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

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

@@ -0,0 +1,108 @@
+#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 code points at
+  // all.
+  {
+    utf32_string_t a, b;
+    utf32_string_init(&a);
+    utf32_string_init(&b);
+
+    assert(utf32_string_compare(&a, &b) == 0);
+
+    static const utf32_t nothing[] = {0};
+
+    utf32_string_view_t empty = utf32_string_view_init(nothing, 0);
+
+    assert(utf32_string_view_compare(empty, empty) == 0);
+    assert(utf32_string_compare_literal(&a, nothing, 0) == 0);
+    assert(utf32_string_view_compare_literal(empty, nothing, 0) == 0);
+
+    utf32_string_destroy(&a);
+    utf32_string_destroy(&b);
+  }
+
+  // Ordering follows the code points, with the shorter of two strings that share
+  // a prefix coming first.
+  {
+    static const utf32_t banana[] = {'b', 'a', 'n', 'a', 'n', 'a', 0};
+    static const utf32_t banan[] = {'b', 'a', 'n', 'a', 'n', 0};
+    static const utf32_t bananas[] = {'b', 'a', 'n', 'a', 'n', 'a', 's', 0};
+    static const utf32_t apple[] = {'a', 'p', 'p', 'l', 'e', 0};
+    static const utf32_t cherry[] = {'c', 'h', 'e', 'r', 'r', 'y', 0};
+
+    utf32_string_t a;
+    utf32_string_init(&a);
+
+    e = utf32_string_append_literal(&a, banana, (size_t) -1);
+    assert(e == 0);
+    assert(a.len == 6);
+
+    assert(utf32_string_compare_literal(&a, banana, (size_t) -1) == 0);
+    assert(utf32_string_compare_literal(&a, banan, (size_t) -1) > 0);
+    assert(utf32_string_compare_literal(&a, bananas, (size_t) -1) < 0);
+    assert(utf32_string_compare_literal(&a, apple, (size_t) -1) > 0);
+    assert(utf32_string_compare_literal(&a, cherry, (size_t) -1) < 0);
+
+    utf32_string_destroy(&a);
+  }
+
+  // Ordering is by the value of a code point rather than by its bytes. A
+  // `memcmp` would put U+0100 before U+00FF on a little endian platform, its
+  // first byte being the lesser of the two.
+  {
+    static const utf32_t high[] = {0x100};
+    static const utf32_t low[] = {0xff};
+
+    utf32_string_view_t a = utf32_string_view_init(high, 1);
+    utf32_string_view_t b = utf32_string_view_init(low, 1);
+
+    assert(utf32_string_view_compare(a, b) > 0);
+    assert(utf32_string_view_compare(b, a) < 0);
+  }
+
+  // The same holds above the basic multilingual plane, where a `memcmp` would
+  // put U+10000 before U+FFFF.
+  {
+    static const utf32_t supplementary[] = {0x10000};
+    static const utf32_t basic[] = {0xffff};
+
+    utf32_string_view_t a = utf32_string_view_init(supplementary, 1);
+    utf32_string_view_t b = utf32_string_view_init(basic, 1);
+
+    assert(utf32_string_view_compare(a, b) > 0);
+    assert(utf32_string_view_compare(b, a) < 0);
+  }
+
+  // A null code point is compared like any other, rather than ending the
+  // comparison as it would were these C strings.
+  {
+    static const utf32_t abc[] = {'a', 0, 'b'};
+    static const utf32_t acc[] = {'a', 0, 'c'};
+    static const utf32_t ab[] = {'a', 0};
+
+    utf32_string_view_t a = utf32_string_view_init(abc, 3);
+    utf32_string_view_t b = utf32_string_view_init(acc, 3);
+    utf32_string_view_t c = utf32_string_view_init(abc, 3);
+
+    assert(utf32_string_view_compare(a, b) < 0);
+    assert(utf32_string_view_compare(b, a) > 0);
+    assert(utf32_string_view_compare(a, c) == 0);
+
+    // The code points past a null one also tell apart strings of unequal length.
+    utf32_string_view_t d = utf32_string_view_init(ab, 2);
+
+    assert(utf32_string_view_compare(d, a) < 0);
+    assert(utf32_string_view_compare(a, d) > 0);
+
+    assert(utf32_string_view_compare_literal(a, abc, 3) == 0);
+    assert(utf32_string_view_compare_literal(a, acc, 3) < 0);
+  }
+}

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

@@ -0,0 +1,79 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.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 hello[] = {'h', 'e', 'l', 'l', 'o', 0};
+  static const utf32_t he[] = {'h', 'e', 0};
+  static const utf32_t h[] = {'h', 0};
+
+  // Plain erase in the middle.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_erase(&s, 5, 6);
+    assert(e == 0);
+    assert(s.len == 5);
+    assert(utf32_string_compare_literal(&s, hello, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Erase with len > string->len - pos must clamp.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_erase(&s, 2, 100);
+    assert(e == 0);
+    assert(s.len == 2);
+    assert(utf32_string_compare_literal(&s, he, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Erase with pos + len overflowing size_t must also clamp.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_erase(&s, 1, SIZE_MAX);
+    assert(e == 0);
+    assert(s.len == 1);
+    assert(utf32_string_compare_literal(&s, h, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Erase with pos > string->len is an error.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_erase(&s, 10, 1);
+    assert(e == -1);
+    assert(s.len == 5);
+
+    utf32_string_destroy(&s);
+  }
+}

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

@@ -0,0 +1,102 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  static const utf32_t banana[] = {'b', 'a', 'n', 'a', 'n', 'a', 0};
+  static const utf32_t abc[] = {'a', 'b', 'c', 0};
+
+  // Empty string with pos = 0 or pos = (size_t) -1 must return not-found rather
+  // than search over a length of SIZE_MAX.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    assert(utf32_string_index_of_character(&s, 0, 'a') == (size_t) -1);
+    assert(utf32_string_index_of_character(&s, (size_t) -1, 'a') == (size_t) -1);
+
+    utf32_string_view_t view = utf32_string_view_init(banana, 0);
+    assert(utf32_string_view_index_of_character(view, 0, 'a') == (size_t) -1);
+    assert(utf32_string_view_index_of_character(view, (size_t) -1, 'a') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Search from the start and find the first match.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, banana, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_index_of_character(&s, 0, 'b') == 0);
+    assert(utf32_string_index_of_character(&s, 0, 'a') == 1);
+    assert(utf32_string_index_of_character(&s, 0, 'n') == 2);
+
+    // Searching from a later position skips the earlier matches.
+    assert(utf32_string_index_of_character(&s, 1, 'a') == 1);
+    assert(utf32_string_index_of_character(&s, 2, 'a') == 3);
+    assert(utf32_string_index_of_character(&s, 4, 'a') == 5);
+    assert(utf32_string_index_of_character(&s, 5, 'n') == (size_t) -1);
+
+    utf32_string_view_t view = utf32_string_view(&s);
+
+    assert(utf32_string_view_index_of_character(view, 0, 'b') == 0);
+    assert(utf32_string_view_index_of_character(view, 2, 'a') == 3);
+    assert(utf32_string_view_index_of_character(view, 5, 'n') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // A search with no match returns not-found.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, abc, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_index_of_character(&s, 0, 'z') == (size_t) -1);
+
+    // pos at or past the end returns not-found.
+    assert(utf32_string_index_of_character(&s, 3, 'a') == (size_t) -1);
+    assert(utf32_string_index_of_character(&s, 100, 'a') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // A null code point is one like any other, both to search for and to search
+  // past.
+  {
+    static const utf32_t with_null[] = {'a', 0, 'b'};
+
+    utf32_string_view_t view = utf32_string_view_init(with_null, 3);
+
+    assert(utf32_string_view_index_of_character(view, 0, 0) == 1);
+    assert(utf32_string_view_index_of_character(view, 0, 'b') == 2);
+  }
+
+  // A code point outside the basic multilingual plane is found by its value, not
+  // by any single byte of it.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_character(&s, 0x10348);
+    assert(e == 0);
+
+    e = utf32_string_append_character(&s, 0x48);
+    assert(e == 0);
+
+    assert(utf32_string_index_of_character(&s, 0, 0x10348) == 0);
+    assert(utf32_string_index_of_character(&s, 0, 0x48) == 1);
+
+    utf32_string_destroy(&s);
+  }
+}

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

@@ -0,0 +1,92 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  static const utf32_t hello[] = {'h', 'e', 'l', 'l', 'o', 0};
+
+  // Inserting in the middle shifts the tail along.
+  {
+    static const utf32_t there[] = {' ', 't', 'h', 'e', 'r', 'e', 0};
+    static const utf32_t expected[] = {'h', 'e', 'l', ' ', 't', 'h', 'e', 'r', 'e', 'l', 'o', 0};
+
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_insert_literal(&string, 3, there, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_compare_literal(&string, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&string);
+  }
+
+  // Inserting at either end is a prepend and an append respectively.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_insert_character(&string, 0, '<');
+    assert(e == 0);
+
+    e = utf32_string_insert_character(&string, string.len, '>');
+    assert(e == 0);
+
+    assert(string.len == 7);
+    assert(string.data[0] == '<');
+    assert(string.data[6] == '>');
+
+    utf32_string_destroy(&string);
+  }
+
+  // Inserting past the end is an error, leaving the string untouched.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_insert_character(&string, 6, 'x');
+    assert(e == -1);
+    assert(string.len == 5);
+
+    e = utf32_string_insert_character(&string, (size_t) -1, 'x');
+    assert(e == -1);
+    assert(string.len == 5);
+
+    utf32_string_destroy(&string);
+  }
+
+  // Repeatedly inserting at a position grows the string past the inline buffer
+  // without disturbing the order of what is already there.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    for (size_t i = 0; i < UTF32_STRING_INLINE_CAPACITY * 2; i++) {
+      e = utf32_string_insert_character(&string, i, (utf32_t) (0x30000 + i));
+      assert(e == 0);
+    }
+
+    assert(string.len == UTF32_STRING_INLINE_CAPACITY * 2);
+    assert(string.data != string.buf);
+
+    for (size_t i = 0; i < string.len; i++) {
+      assert(string.data[i] == 0x30000 + i);
+    }
+
+    utf32_string_destroy(&string);
+  }
+}

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

@@ -0,0 +1,71 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  static const utf32_t banana[] = {'b', 'a', 'n', 'a', 'n', 'a', 0};
+  static const utf32_t abc[] = {'a', 'b', 'c', 0};
+
+  // Empty string with pos = (size_t) -1 must return not-found instead of
+  // reading data[SIZE_MAX].
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    assert(utf32_string_last_index_of_character(&s, (size_t) -1, 'a') == (size_t) -1);
+
+    utf32_string_view_t view = utf32_string_view_init(banana, 0);
+    assert(utf32_string_view_last_index_of_character(view, (size_t) -1, 'a') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Search from the end and find a match.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, banana, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_last_index_of_character(&s, (size_t) -1, 'a') == 5);
+    assert(utf32_string_last_index_of_character(&s, (size_t) -1, 'n') == 4);
+    assert(utf32_string_last_index_of_character(&s, (size_t) -1, 'b') == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Search with no match must terminate (loop must not run forever or read
+  // before the buffer).
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, abc, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_last_index_of_character(&s, (size_t) -1, 'z') == (size_t) -1);
+    assert(utf32_string_last_index_of_character(&s, 0, 'z') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // pos >= string->len returns not-found.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, abc, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_last_index_of_character(&s, 3, 'a') == (size_t) -1);
+    assert(utf32_string_last_index_of_character(&s, 100, 'a') == (size_t) -1);
+
+    utf32_string_destroy(&s);
+  }
+}

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

@@ -0,0 +1,51 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+int
+main() {
+  int e;
+
+  static const utf32_t hello[] = {'h', 'e', 'l', 'l', 'o', 0};
+  static const utf32_t world[] = {' ', 'w', 'o', 'r', 'l', 'd', 0};
+  static const utf32_t expected[] = {'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0};
+
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_prepend_literal(&string, world, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_prepend_literal(&string, hello, (size_t) -1);
+    assert(e == 0);
+
+    assert(string.len == 11);
+    assert(utf32_string_compare_literal(&string, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&string);
+  }
+
+  // Prepending a single code point shifts the rest along, including once the
+  // string has outgrown the inline buffer.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    for (size_t i = 0; i < UTF32_STRING_INLINE_CAPACITY * 2; i++) {
+      e = utf32_string_prepend_character(&string, (utf32_t) (0x20000 + i));
+      assert(e == 0);
+    }
+
+    assert(string.len == UTF32_STRING_INLINE_CAPACITY * 2);
+
+    // The first code point prepended ended up last.
+    for (size_t i = 0; i < string.len; i++) {
+      assert(string.data[i] == 0x20000 + (string.len - 1 - i));
+    }
+
+    utf32_string_destroy(&string);
+  }
+}

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

@@ -0,0 +1,88 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.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 hello[] = {'h', 'e', 'l', 'l', 'o', 0};
+
+  {
+    static const utf32_t there[] = {' ', 't', 'h', 'e', 'r', 'e', ' ', 0};
+    static const utf32_t expected[] = {'h', 'e', 'l', 'l', 'o', ' ', 't', 'h', 'e', 'r', 'e', ' ', 'w', 'o', 'r', 'l', 'd', 0};
+
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello_world, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_replace_literal(&string, 5, 1, there, (size_t) -1);
+    assert(e == 0);
+
+    assert(utf32_string_compare_literal(&string, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&string);
+  }
+
+  // replace_character must clamp len to (string->len - pos) so memmove doesn't
+  // underflow size_t.
+  {
+    static const utf32_t expected[] = {'h', 'e', 'X', 0};
+
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_replace_character(&s, 2, 100, 'X');
+    assert(e == 0);
+    assert(s.len == 3);
+    assert(utf32_string_compare_literal(&s, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // replace_character with pos + len overflowing size_t must also clamp.
+  {
+    static const utf32_t expected[] = {'h', 'Y', 0};
+
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_replace_character(&s, 1, SIZE_MAX, 'Y');
+    assert(e == 0);
+    assert(s.len == 2);
+    assert(utf32_string_compare_literal(&s, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+
+  // replace_literal with pos + len overflowing size_t must also clamp.
+  {
+    static const utf32_t replacement[] = {'i', '!', 0};
+    static const utf32_t expected[] = {'h', 'i', '!', 0};
+
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_append_literal(&s, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_replace_literal(&s, 1, SIZE_MAX, replacement, 2);
+    assert(e == 0);
+    assert(s.len == 3);
+    assert(utf32_string_compare_literal(&s, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&s);
+  }
+}

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

@@ -0,0 +1,99 @@
+#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.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, 512);
+    assert(e == 0);
+    assert(s.data != s.buf);
+    assert(s.cap >= 512);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Reserve within the inline buffer is a no-op. The capacity counts code
+  // points, so the whole of the buffer is available rather than a quarter of it.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, UTF32_STRING_INLINE_CAPACITY);
+    assert(e == 0);
+    assert(s.data == s.buf);
+
+    utf32_string_destroy(&s);
+  }
+
+  // One code point past the inline buffer does allocate.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, UTF32_STRING_INLINE_CAPACITY + 1);
+    assert(e == 0);
+    assert(s.data != s.buf);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Reserve must reject sizes that would overflow the power-of-two rounding,
+  // rather than wrapping to cap = 0 and returning success.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, SIZE_MAX);
+    assert(e == -1);
+
+    e = utf32_string_reserve(&s, (SIZE_MAX >> 1) + 2);
+    assert(e == -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Reserve must also reject a count of code points that survives the rounding
+  // but overflows once scaled to the number of bytes that they occupy. This has
+  // no counterpart for UTF-8, where a code unit is a single byte.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, SIZE_MAX / sizeof(utf32_t));
+    assert(e == -1);
+
+    utf32_string_destroy(&s);
+  }
+
+  // Shrinking back to within the inline buffer returns to it, keeping the
+  // contents.
+  {
+    utf32_string_t s;
+    utf32_string_init(&s);
+
+    e = utf32_string_reserve(&s, 512);
+    assert(e == 0);
+    assert(s.data != s.buf);
+
+    e = utf32_string_append_character(&s, 0x10348);
+    assert(e == 0);
+
+    e = utf32_string_shrink_to_fit(&s);
+    assert(e == 0);
+    assert(s.data == s.buf);
+    assert(s.len == 1);
+    assert(s.data[0] == 0x10348);
+
+    utf32_string_destroy(&s);
+  }
+}