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

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

@@ -0,0 +1,32 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+#define test_convert(string, len, expected, written) \
+  { \
+    utf16_t result[len]; \
+    assert(utf8_convert_to_utf16le((utf8_t *) string, len, result) == written); \
+    assert(memcmp(expected, result, written) == 0); \
+  }
+
+int
+main() {
+  // ASCII character 'A'
+  test_convert("\x41", 1, "\x41\x00", 1);
+
+  // Greek capital letter 'Ω'
+  test_convert("\xce\xa9", 2, "\xa9\x03", 1);
+
+  // Snowman symbol '☃'
+  test_convert("\xe2\x98\x83", 3, "\x03\x26", 1);
+
+  // Chinese character '中'
+  test_convert("\xe4\xb8\xad", 3, "\x2d\x4e", 1);
+
+  // Face with tears of joy emoji '😂'
+  test_convert("\xf0\x9f\x98\x82", 4, "\x3d\xd8\x02\xde", 2);
+
+  // Multiple characters "AΩ☃中😂"
+  test_convert("\x41\xce\xa9\xe2\x98\x83\xe4\xb8\xad\xf0\x9f\x98\x82", 13, "\x41\x00\xa9\x03\x03\x26\x2d\x4e\x3d\xd8\x02\xde", 6);
+}

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

@@ -0,0 +1,29 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_length(string, len, expected) \
+  { \
+    assert(utf16_length_from_utf8((utf8_t *) string, len) == expected); \
+  }
+
+int
+main() {
+  // ASCII character 'A'
+  test_length("\x41", 1, 1);
+
+  // Greek capital letter 'Ω'
+  test_length("\xce\xa9", 2, 1);
+
+  // Snowman symbol '☃'
+  test_length("\xe2\x98\x83", 3, 1);
+
+  // Chinese character '中'
+  test_length("\xe4\xb8\xad", 3, 1);
+
+  // Face with tears of joy emoji '😂'
+  test_length("\xf0\x9f\x98\x82", 4, 2);
+
+  // Multiple characters "AΩ☃中😂"
+  test_length("\x41\xce\xa9\xe2\x98\x83\xe4\xb8\xad\xf0\x9f\x98\x82", 13, 6);
+}

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

@@ -0,0 +1,26 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_validate(string, len) \
+  { \
+    assert(!utf8_validate((utf8_t *) string, len)); \
+  }
+
+int
+main() {
+  test_validate("\x80", 1);                     // The byte is 10000000 in binary. The first bit suggests it's a continuation byte, but there's no start byte.
+  test_validate("\xc3", 1);                     // This byte indicates the start of a 2-byte sequence, but it's missing the second byte.
+  test_validate("\xc0\x80", 2);                 // Overlong encoding of NULL character, which should be 0x00 in UTF-8
+  test_validate("\xc3\xa9\xa8", 3);             // This starts as a valid 2-byte sequence, but then has an unexpected third byte.
+  test_validate("\x80\x80", 2);                 // This sequence starts with a continuation byte, which is not allowed.
+  test_validate("\xfe", 1);                     // This byte indicates the start of a sequence of length 7, but UTF-8 only supports up to 4-byte sequences.
+  test_validate("\xe2\x82", 2);                 // This start byte indicates a 3-byte sequence, but only one additional byte is provided.
+  test_validate("\xf4\x90\x80\x80", 4);         // This sequence decodes to U+110000, which is beyond the U+10FFFF limit of Unicode.
+  test_validate("\xed\xa0\x80", 3);             // This sequence decodes to U+D800, a high surrogate.
+  test_validate("\xed\xbf\xbf", 3);             // This sequence decodes to U+DFFF, a low surrogate.
+  test_validate("\xe2\x82\xc0", 3);             // The last byte should be a continuation byte (10xxxxxx), but it's a start byte (110xxxxx).
+  test_validate("\x80\xc2", 2);                 // This sequence starts with a continuation byte, which is not allowed.
+  test_validate("\xf8\x88\x88\x88\x88", 5);     // UTF-8 only supports up to 4-byte sequences.
+  test_validate("\xfc\x84\x84\x84\x84\x84", 6); // UTF-8 only supports up to 4-byte sequences.
+}

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

@@ -0,0 +1,21 @@
+#include <assert.h>
+
+#include "../../include/utf.h"
+
+#define test_validate(string, len) \
+  { \
+    assert(utf8_validate((utf8_t *) string, len)); \
+  }
+
+int
+main() {
+  test_validate("a", 1);                                                 // Single ASCII character
+  test_validate("Hello, World!", 13);                                    // ASCII characters
+  test_validate("\xc3\xa9", 2);                                          // Single 2-byte UTF-8 character
+  test_validate("\xc3\xa9\xc3\xa8\xc3\xaa\xc3\xab\xc3\xaf", 10);         // String of 2-byte UTF-8 characters
+  test_validate("\xe2\x82\xac", 3);                                      // Single 3-byte UTF-8 character
+  test_validate("\xe2\x82\xac\xe2\x89\xa1\xe2\x9c\x93", 9);              // String of 3-byte UTF-8 characters
+  test_validate("\xf0\x9f\x98\x80", 4);                                  // Single 4-byte UTF-8 character
+  test_validate("\xf0\x9f\x98\x80\xf0\x9f\x98\x81\xf0\x9f\x98\x82", 12); // String of 4-byte UTF-8 characters
+  test_validate("a \xc3\xa9 \xe2\x82\xac \xf0\x9f\x98\x80", 13);         // Mix of all
+}

package/global.d.ts

@@ -0,0 +1,21 @@
+import * as buffer from '.'
+
+type BufferConstructor = typeof buffer.Buffer
+
+declare global {
+  /** A fixed-length view of binary data, backed by an `ArrayBuffer` and extending `Uint8Array`. */
+  type Buffer = buffer.Buffer
+
+  const Buffer: BufferConstructor
+
+  /**
+   * Decode a base64-encoded string into a Latin-1 binary string.
+   * @param data - The base64-encoded string to decode.
+   */
+  const atob: typeof buffer.atob
+  /**
+   * Encode a Latin-1 binary string into a base64 string.
+   * @param data - The value to encode; non-strings are coerced with `String()`.
+   */
+  const btoa: typeof buffer.btoa
+}

package/global.js

@@ -0,0 +1,6 @@
+const Buffer = require('.')
+
+global.Buffer = Buffer
+
+global.atob = Buffer.atob
+global.btoa = Buffer.btoa