summaryrefslogtreecommitdiffstats
path: root/js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp')
-rw-r--r--js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp162
1 files changed, 162 insertions, 0 deletions
diff --git a/js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp b/js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp
new file mode 100644
index 0000000000..b451fc4e2b
--- /dev/null
+++ b/js/src/jsapi-tests/testDeflateStringToUTF8Buffer.cpp
@@ -0,0 +1,162 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "jsapi-tests/tests.h"
+
+using namespace JS;
+
+BEGIN_TEST(test_DeflateStringToUTF8Buffer) {
+ JSString* str;
+ JSLinearString* linearStr;
+
+ // DeflateStringToUTF8Buffer does not write a null terminator, so the byte
+ // following the last byte written to the |actual| buffer should retain
+ // the value it held before the call to DeflateStringToUTF8Buffer, which is
+ // initialized to 0x1.
+
+ char actual[100];
+ auto span = mozilla::Span(actual);
+
+ // Test with an ASCII string, which calls JSLinearString::latin1Chars
+ // to retrieve the characters from the string and generates UTF-8 output
+ // that is identical to the ASCII input.
+
+ str = JS_NewStringCopyZ(cx, "Ohai"); // { 0x4F, 0x68, 0x61, 0x69 }
+ MOZ_RELEASE_ASSERT(str);
+ linearStr = JS_EnsureLinearString(cx, str);
+
+ {
+ const char expected[] = {0x4F, 0x68, 0x61, 0x69, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span);
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 4u);
+ }
+
+ {
+ const char expected[] = {0x4F, 0x68, 0x61, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(3));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 3u);
+ }
+
+ {
+ const unsigned char expected[] = {0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(0));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 0u);
+ }
+
+ // Test with a Latin-1 string, which calls JSLinearString::latin1Chars
+ // like with the ASCII string but generates UTF-8 output that is different
+ // from the ASCII input.
+
+ str = JS_NewUCStringCopyZ(cx, u"\xD3\x68\xE3\xEF"); // u"Óhãï"
+ MOZ_RELEASE_ASSERT(str);
+ linearStr = JS_EnsureLinearString(cx, str);
+
+ {
+ const unsigned char expected[] = {0xC3, 0x93, 0x68, 0xC3,
+ 0xA3, 0xC3, 0xAF, 0x1};
+ memset(actual, 0x1, 100);
+ JS::DeflateStringToUTF8Buffer(linearStr, span);
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ }
+
+ {
+ const unsigned char expected[] = {0xC3, 0x93, 0x68, 0xC3,
+ 0xA3, 0xC3, 0xAF, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(7));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 7u);
+ }
+
+ {
+ // Specify a destination buffer length of 3. That's exactly enough
+ // space to encode the first two characters, which takes three bytes.
+ const unsigned char expected[] = {0xC3, 0x93, 0x68, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(3));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 3u);
+ }
+
+ {
+ // Specify a destination buffer length of 4. That's only enough space
+ // to encode the first two characters, which takes three bytes, because
+ // the third character would take another two bytes.
+ const unsigned char expected[] = {0xC3, 0x93, 0x68, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(4));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 3u);
+ }
+
+ {
+ const unsigned char expected[] = {0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(0));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 0u);
+ }
+
+ // Test with a UTF-16 string, which calls JSLinearString::twoByteChars
+ // to retrieve the characters from the string.
+
+ str = JS_NewUCStringCopyZ(cx, u"\x038C\x0068\x0203\x0457"); // u"Όhȃї"
+ MOZ_RELEASE_ASSERT(str);
+ linearStr = JS_EnsureLinearString(cx, str);
+
+ {
+ const unsigned char expected[] = {0xCE, 0x8C, 0x68, 0xC8,
+ 0x83, 0xD1, 0x97, 0x1};
+ memset(actual, 0x1, 100);
+ JS::DeflateStringToUTF8Buffer(linearStr, span);
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ }
+
+ {
+ const unsigned char expected[] = {0xCE, 0x8C, 0x68, 0xC8,
+ 0x83, 0xD1, 0x97, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(7));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 7u);
+ }
+
+ {
+ // Specify a destination buffer length of 3. That's exactly enough
+ // space to encode the first two characters, which takes three bytes.
+ const unsigned char expected[] = {0xCE, 0x8C, 0x68, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(3));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 3u);
+ }
+
+ {
+ // Specify a destination buffer length of 4. That's only enough space
+ // to encode the first two characters, which takes three bytes, because
+ // the third character would take another two bytes.
+ const unsigned char expected[] = {0xCE, 0x8C, 0x68, 0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(4));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 3u);
+ }
+
+ {
+ const unsigned char expected[] = {0x1};
+ memset(actual, 0x1, 100);
+ size_t dstlen = JS::DeflateStringToUTF8Buffer(linearStr, span.To(0));
+ CHECK_EQUAL(memcmp(actual, expected, sizeof(expected)), 0);
+ CHECK_EQUAL(dstlen, 0u);
+ }
+
+ return true;
+}
+END_TEST(test_DeflateStringToUTF8Buffer)