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

package/deps/libutf/test/fuzz/latin1/convert-to-utf16.c

@@ -0,0 +1,32 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Each Latin-1 byte maps to one UTF-16 unit.
+  utf16_t *utf16 = size > 0 ? malloc(size * sizeof(utf16_t)) : NULL;
+
+  size_t utf16_len = latin1_convert_to_utf16le((const latin1_t *) data, size, utf16);
+
+  assert(utf16_len == size);
+
+  if (size > 0) {
+    latin1_t *latin1 = malloc(size);
+
+    size_t latin1_len = utf16le_convert_to_latin1(utf16, utf16_len, latin1);
+
+    assert(latin1_len == size);
+    assert(memcmp(latin1, data, size) == 0);
+
+    free(latin1);
+  }
+
+  free(utf16);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/latin1/convert-to-utf32.c

@@ -0,0 +1,32 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Each Latin-1 byte maps to one UTF-32 unit.
+  utf32_t *utf32 = size > 0 ? malloc(size * sizeof(utf32_t)) : NULL;
+
+  size_t utf32_len = latin1_convert_to_utf32((const latin1_t *) data, size, utf32);
+
+  assert(utf32_len == size);
+
+  if (size > 0) {
+    latin1_t *latin1 = malloc(size);
+
+    size_t latin1_len = utf32_convert_to_latin1(utf32, utf32_len, latin1);
+
+    assert(latin1_len == size);
+    assert(memcmp(latin1, data, size) == 0);
+
+    free(latin1);
+  }
+
+  free(utf32);
+
+  return 0;
+}

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

@@ -0,0 +1,33 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Each Latin-1 byte expands to at most 2 UTF-8 bytes.
+  utf8_t *utf8 = size > 0 ? malloc(size * 2) : NULL;
+
+  size_t utf8_len = latin1_convert_to_utf8((const latin1_t *) data, size, utf8);
+
+  assert(utf8_len >= size);
+  assert(utf8_len <= size * 2);
+
+  if (size > 0) {
+    latin1_t *latin1 = malloc(size);
+
+    size_t latin1_len = utf8_convert_to_latin1(utf8, utf8_len, latin1);
+
+    assert(latin1_len == size);
+    assert(memcmp(latin1, data, size) == 0);
+
+    free(latin1);
+  }
+
+  free(utf8);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf16/convert-to-latin1.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf16_t);
+  const utf16_t *input = (const utf16_t *) data;
+
+  // Each UTF-16 unit maps to at most one Latin-1 byte.
+  latin1_t *latin1 = units > 0 ? malloc(units) : NULL;
+
+  size_t latin1_len = utf16le_convert_to_latin1(input, units, latin1);
+
+  assert(latin1_len <= units);
+
+  if (latin1_len > 0) {
+    // Each Latin-1 byte maps to one UTF-16 unit.
+    utf16_t *utf16 = malloc(latin1_len * sizeof(utf16_t));
+
+    size_t utf16_len = latin1_convert_to_utf16le(latin1, latin1_len, utf16);
+
+    assert(utf16_len == units);
+    assert(memcmp(utf16, input, units * sizeof(utf16_t)) == 0);
+
+    free(utf16);
+  }
+
+  free(latin1);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf16/convert-to-utf32.c

@@ -0,0 +1,38 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf16_t);
+  const utf16_t *input = (const utf16_t *) data;
+
+  if (!utf16le_validate(input, units)) return -1;
+
+  // UTF-32 unit count never exceeds UTF-16 unit count.
+  utf32_t *utf32 = units > 0 ? malloc(units * sizeof(utf32_t)) : NULL;
+
+  size_t utf32_len = utf16le_convert_to_utf32(input, units, utf32);
+
+  assert(utf32_len <= units);
+
+  if (units > 0) {
+    // Each UTF-32 unit expands to at most 2 UTF-16 units (surrogate pair).
+    utf16_t *utf16 = malloc(utf32_len * 2 * sizeof(utf16_t));
+
+    size_t utf16_len = utf32_convert_to_utf16le(utf32, utf32_len, utf16);
+
+    assert(utf16_len == units);
+    assert(memcmp(utf16, input, units * sizeof(utf16_t)) == 0);
+
+    free(utf16);
+  }
+
+  free(utf32);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf16/convert-to-utf8.c

@@ -0,0 +1,38 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf16_t);
+  const utf16_t *input = (const utf16_t *) data;
+
+  if (!utf16le_validate(input, units)) return -1;
+
+  // Each UTF-16 unit expands to at most 3 UTF-8 bytes.
+  utf8_t *utf8 = units > 0 ? malloc(units * 3) : NULL;
+
+  size_t utf8_len = utf16le_convert_to_utf8(input, units, utf8);
+
+  assert(utf8_len <= units * 3);
+
+  if (units > 0) {
+    // UTF-16 unit count never exceeds UTF-8 byte count.
+    utf16_t *utf16 = malloc(utf8_len * sizeof(utf16_t));
+
+    size_t utf16_len = utf8_convert_to_utf16le(utf8, utf8_len, utf16);
+
+    assert(utf16_len == units);
+    assert(memcmp(utf16, input, units * sizeof(utf16_t)) == 0);
+
+    free(utf16);
+  }
+
+  free(utf8);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf32/convert-to-latin1.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf32_t);
+  const utf32_t *input = (const utf32_t *) data;
+
+  // Each UTF-32 unit maps to at most one Latin-1 byte.
+  latin1_t *latin1 = units > 0 ? malloc(units) : NULL;
+
+  size_t latin1_len = utf32_convert_to_latin1(input, units, latin1);
+
+  assert(latin1_len <= units);
+
+  if (latin1_len > 0) {
+    // Each Latin-1 byte maps to one UTF-32 unit.
+    utf32_t *utf32 = malloc(latin1_len * sizeof(utf32_t));
+
+    size_t utf32_len = latin1_convert_to_utf32(latin1, latin1_len, utf32);
+
+    assert(utf32_len == units);
+    assert(memcmp(utf32, input, units * sizeof(utf32_t)) == 0);
+
+    free(utf32);
+  }
+
+  free(latin1);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf32/convert-to-utf16.c

@@ -0,0 +1,38 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf32_t);
+  const utf32_t *input = (const utf32_t *) data;
+
+  if (!utf32_validate(input, units)) return -1;
+
+  // Each UTF-32 unit expands to at most 2 UTF-16 units (surrogate pair).
+  utf16_t *utf16 = units > 0 ? malloc(units * 2 * sizeof(utf16_t)) : NULL;
+
+  size_t utf16_len = utf32_convert_to_utf16le(input, units, utf16);
+
+  assert(utf16_len <= units * 2);
+
+  if (units > 0) {
+    // UTF-32 unit count never exceeds UTF-16 unit count.
+    utf32_t *utf32 = malloc(utf16_len * sizeof(utf32_t));
+
+    size_t utf32_len = utf16le_convert_to_utf32(utf16, utf16_len, utf32);
+
+    assert(utf32_len == units);
+    assert(memcmp(utf32, input, units * sizeof(utf32_t)) == 0);
+
+    free(utf32);
+  }
+
+  free(utf16);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf32/convert-to-utf8.c

@@ -0,0 +1,38 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  size_t units = size / sizeof(utf32_t);
+  const utf32_t *input = (const utf32_t *) data;
+
+  if (!utf32_validate(input, units)) return -1;
+
+  // Each UTF-32 unit expands to at most 4 UTF-8 bytes.
+  utf8_t *utf8 = units > 0 ? malloc(units * 4) : NULL;
+
+  size_t utf8_len = utf32_convert_to_utf8(input, units, utf8);
+
+  assert(utf8_len <= units * 4);
+
+  if (units > 0) {
+    // UTF-32 unit count never exceeds UTF-8 byte count.
+    utf32_t *utf32 = malloc(utf8_len * sizeof(utf32_t));
+
+    size_t utf32_len = utf8_convert_to_utf32(utf8, utf8_len, utf32);
+
+    assert(utf32_len == units);
+    assert(memcmp(utf32, input, units * sizeof(utf32_t)) == 0);
+
+    free(utf32);
+  }
+
+  free(utf8);
+
+  return 0;
+}

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

@@ -0,0 +1,33 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Latin-1 output is never longer than the UTF-8 input.
+  latin1_t *latin1 = size > 0 ? malloc(size) : NULL;
+
+  size_t latin1_len = utf8_convert_to_latin1((const utf8_t *) data, size, latin1);
+
+  assert(latin1_len <= size);
+
+  if (latin1_len > 0) {
+    // Each Latin-1 byte expands to at most 2 UTF-8 bytes.
+    utf8_t *utf8 = malloc(latin1_len * 2);
+
+    size_t utf8_len = latin1_convert_to_utf8(latin1, latin1_len, utf8);
+
+    assert(utf8_len == size);
+    assert(memcmp(utf8, data, size) == 0);
+
+    free(utf8);
+  }
+
+  free(latin1);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf8/convert-to-utf16.c

@@ -0,0 +1,35 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  if (!utf8_validate((const utf8_t *) data, size)) return -1;
+
+  // UTF-16 unit count never exceeds UTF-8 byte count.
+  utf16_t *utf16 = size > 0 ? malloc(size * sizeof(utf16_t)) : NULL;
+
+  size_t utf16_len = utf8_convert_to_utf16le((const utf8_t *) data, size, utf16);
+
+  assert(utf16_len <= size);
+
+  if (size > 0) {
+    // Each UTF-16 unit expands to at most 3 UTF-8 bytes.
+    utf8_t *utf8 = malloc(utf16_len * 3);
+
+    size_t utf8_len = utf16le_convert_to_utf8(utf16, utf16_len, utf8);
+
+    assert(utf8_len == size);
+    assert(memcmp(utf8, data, size) == 0);
+
+    free(utf8);
+  }
+
+  free(utf16);
+
+  return 0;
+}

package/deps/libutf/test/fuzz/utf8/convert-to-utf32.c

@@ -0,0 +1,35 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/utf.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  if (!utf8_validate((const utf8_t *) data, size)) return -1;
+
+  // UTF-32 unit count never exceeds UTF-8 byte count.
+  utf32_t *utf32 = size > 0 ? malloc(size * sizeof(utf32_t)) : NULL;
+
+  size_t utf32_len = utf8_convert_to_utf32((const utf8_t *) data, size, utf32);
+
+  assert(utf32_len <= size);
+
+  if (size > 0) {
+    // Each UTF-32 unit expands to at most 4 UTF-8 bytes.
+    utf8_t *utf8 = malloc(utf32_len * 4);
+
+    size_t utf8_len = utf32_convert_to_utf8(utf32, utf32_len, utf8);
+
+    assert(utf8_len == size);
+    assert(memcmp(utf8, data, size) == 0);
+
+    free(utf8);
+  }
+
+  free(utf32);
+
+  return 0;
+}

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

@@ -0,0 +1,45 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+#define test_convert(string, len, expected, written) \
+  { \
+    utf8_t result[len * 3]; \
+    assert(utf16le_convert_to_utf8((utf16_t *) string, len, result) == written); \
+    assert(memcmp(expected, result, written) == 0); \
+  }
+
+int
+main() {
+  // ASCII only
+  test_convert("\x61\x00\x62\x00\x63\x00", 3, "abc", 3);
+
+  // Greek alphabet
+  test_convert("\xb1\x03\xb2\x03\xb3\x03", 3, "\xce\xb1\xce\xb2\xce\xb3", 6);
+
+  // Chinese characters
+  test_convert("\x4e\x67\xf3\x97\x2d\x4e", 3, "\xe6\x9d\x8e\xe9\x9f\xb3\xe4\xb8\xad", 9);
+
+  // Mix of ASCII, Greek and Chinese
+  test_convert("\x61\x00\xb1\x03\x4e\x67", 3, "a\xce\xb1\xe6\x9d\x8e", 6);
+
+  // Surrogate pair
+  test_convert("\x00\xd8\x37\xdc", 2, "\xf0\x90\x80\xb7", 4);
+
+  // Lone high surrogate followed by ASCII, must skip the surrogate (not consume the ASCII)
+  test_convert("\x00\xd8\x41\x00", 2, "\x41", 1);
+
+  // Lone low surrogate followed by ASCII, must skip the surrogate
+  test_convert("\x00\xdc\x41\x00", 2, "\x41", 1);
+
+  // High surrogate followed by another high surrogate that begins a valid pair
+  test_convert("\x00\xd8\x00\xd8\x37\xdc", 3, "\xf0\x90\x80\xb7", 4);
+
+  // Lone trailing high surrogate (truncated), must not OOB-read
+  {
+    utf8_t result[1] = {0xaa};
+    assert(utf16le_convert_to_utf8((utf16_t *) "\x00\xd8", 1, result) == 0);
+    assert(result[0] == 0xaa);
+  }
+}

package/deps/libutf/test/utf16/utf8-length.c

@@ -0,0 +1,41 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_length(string, len, expected) \
+  { \
+    assert(utf8_length_from_utf16le((utf16_t *) string, len) == expected); \
+  }
+
+int
+main() {
+  // ASCII character 'A'
+  test_length("\x41\x00", 1, 1);
+
+  // Greek capital letter 'Ω'
+  test_length("\xa9\x03", 1, 2);
+
+  // Snowman symbol '☃'
+  test_length("\x03\x26", 1, 3);
+
+  // Chinese character '中'
+  test_length("\x2d\x4e", 1, 3);
+
+  // Face with tears of joy emoji '😂'
+  test_length("\x3d\xd8\x02\xde", 2, 4);
+
+  // Multiple characters 'AΩ☃中😂'
+  test_length("\x41\x00\xa9\x03\x03\x26\x2d\x4e\x3d\xd8\x02\xde", 6, 13);
+
+  // Lone high surrogate followed by ASCII, surrogate contributes 0
+  test_length("\x00\xd8\x41\x00", 2, 1);
+
+  // Lone low surrogate followed by ASCII, surrogate contributes 0
+  test_length("\x00\xdc\x41\x00", 2, 1);
+
+  // Lone trailing high surrogate, contributes 0
+  test_length("\x00\xd8", 1, 0);
+
+  // High surrogate not followed by low surrogate, first contributes 0, pair contributes 4
+  test_length("\x00\xd8\x00\xd8\x37\xdc", 3, 4);
+}

package/deps/libutf/test/utf16/validate-invalid.c

@@ -0,0 +1,50 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_validate(string, len) \
+  { \
+    assert(!utf16le_validate((utf16_t *) string, len)); \
+  }
+
+int
+main() {
+  // An isolated high surrogate
+  test_validate("\x01\xd8", 1);
+
+  // An isolated low surrogate
+  test_validate("\x37\xdc", 1);
+
+  // A high surrogate followed by another high surrogate
+  test_validate("\x01\xd8\x02\xd8", 2);
+
+  // A low surrogate followed by another low surrogate
+  test_validate("\x37\xdc\x38\xdc", 2);
+
+  // A high surrogate followed by a non-surrogate
+  // test_validate("\x01\xd8\xe8\x00", 2);
+
+  // A low surrogate followed by a non-surrogate
+  // test_validate("\x37\xdc\xe8\x00", 2);
+
+  // A non-surrogate followed by a low surrogate
+  // test_validate("\xe8\x00\x37\xdc");
+
+  // A non-surrogate followed by a high surrogate
+  // test_validate("\xe8\x00\x01\xd8");
+
+  // A surrogate pair in the wrong order
+  test_validate("\x37\xdc\x01\xd8", 2);
+
+  // Two high surrogates followed by a low surrogate
+  test_validate("\x01\xd8\x02\xd8\x37\xdc", 3);
+
+  // A high surrogate followed by two low surrogates
+  test_validate("\x01\xd8\x37\xdc\x38\xdc", 3);
+
+  // Two high surrogates in a row
+  test_validate("\x01\xd8\x02\xd8", 2);
+
+  // Two low surrogates in a row
+  test_validate("\x37\xdc\x38\xdc", 2);
+}

package/deps/libutf/test/utf16/validate.c

@@ -0,0 +1,32 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_validate(string, len) \
+  { \
+    assert(utf16le_validate((utf16_t *) string, len)); \
+  }
+
+int
+main() {
+  // Single ASCII character, 'a'
+  test_validate("\x61\x00", 1);
+
+  // String of ASCII characters, "Hello"
+  test_validate("\x48\x00\x65\x00\x6c\x00\x6c\x00\x6f\x00", 5);
+
+  // Single 2-byte UTF-16LE character, 'è'
+  test_validate("\xe8\x00", 1);
+
+  // String of 2-byte UTF-16LE characters, "èéêë"
+  test_validate("\xe8\x00\xe9\x00\xea\x00\xeb\x00", 4);
+
+  // Single 4-byte UTF-16LE character (represented as a surrogate pair), '𐐷'
+  test_validate("\x01\xd8\x37\xdc", 2);
+
+  // String of 4-byte UTF-16LE characters (represented as surrogate pairs), "𐐷𐑏"
+  test_validate("\x01\xd8\x37\xdc\x3f\xd8\x1f\xdc", 4);
+
+  // A mix of 2-byte and 4-byte UTF-16LE characters, "Hello𐐷"
+  test_validate("\x48\x00\x65\x00\x6c\x00\x6c\x00\x6f\x00\x01\xd8\x37\xdc", 7);
+}

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

@@ -0,0 +1,74 @@
+#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};
+
+  // A length of (size_t) -1 takes the length of a null terminated sequence of
+  // code points, standing in for the `strlen` of the UTF-8 string.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    e = utf32_string_append_literal(&string, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_append_literal(&string, world, (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);
+  }
+
+  // Appending code point by code point grows past the inline buffer, keeping
+  // everything that came before.
+  {
+    utf32_string_t string;
+    utf32_string_init(&string);
+
+    for (size_t i = 0; i < UTF32_STRING_INLINE_CAPACITY * 4; i++) {
+      e = utf32_string_append_character(&string, (utf32_t) (0x10000 + i));
+      assert(e == 0);
+    }
+
+    assert(string.len == UTF32_STRING_INLINE_CAPACITY * 4);
+    assert(string.data != string.buf);
+
+    for (size_t i = 0; i < string.len; i++) {
+      assert(string.data[i] == 0x10000 + i);
+    }
+
+    utf32_string_destroy(&string);
+  }
+
+  // Appending a string and a view leaves the same result.
+  {
+    utf32_string_t a, b;
+    utf32_string_init(&a);
+    utf32_string_init(&b);
+
+    e = utf32_string_append_literal(&a, hello, (size_t) -1);
+    assert(e == 0);
+
+    e = utf32_string_append(&b, &a);
+    assert(e == 0);
+
+    e = utf32_string_append_view(&b, utf32_string_view_init(world, 6));
+    assert(e == 0);
+
+    assert(utf32_string_compare_literal(&b, expected, (size_t) -1) == 0);
+
+    utf32_string_destroy(&a);
+    utf32_string_destroy(&b);
+  }
+}