[test] Cleanup UTF tests. NFC (#21876)

Author: sbc100

test/benchmark/benchmark_utf16.cpp

@@ -10,10 +10,12 @@
 #include <cassert>
 #include <emscripten.h>
 
+EM_JS_DEPS(deps, "$UTF16ToString");
+
 double test(const unsigned short *str) {
   double res = EM_ASM_DOUBLE({
     var t0 = _emscripten_get_now();
-    var str = Module.UTF16ToString($0);
+    var str = UTF16ToString($0);
     var t1 = _emscripten_get_now();
     out('t: ' + (t1 - t0) + ', len(result): ' + str.length + ', result: ' + str.slice(0, 100));
     return (t1-t0);

test/core/test_utf16.cpp

@@ -10,6 +10,8 @@
 #include <vector>
 #include <wchar.h>
 
+EM_JS_DEPS(deps, "$UTF16ToString,$stringToUTF16");
+
 // Roundtrip a (non-)null-terminated string between C++ and JS.
 EM_JS(void, roundtripString, (const char16_t* str, int strBytes, char16_t* result, int resultBytes), {
 #if __wasm64__

test/test_core.py

@@ -5670,17 +5670,14 @@ def test_utf(self):
     self.do_core_test('test_utf.c')
 
   def test_utf32(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF32ToString', 'stringToUTF32', 'lengthBytesUTF32'])
     self.do_runf('utf32.cpp', 'OK.')
     self.do_runf('utf32.cpp', 'OK.', args=['-fshort-wchar'])
 
   @crossplatform
   def test_utf16(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF16ToString', 'stringToUTF16'])
     self.do_runf('core/test_utf16.cpp', 'OK.')
 
   def test_utf8(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF8ToString', 'stringToUTF8', 'AsciiToString', 'stringToAscii'])
     self.do_runf('utf8.cpp', 'OK.')
 
   @also_with_wasm_bigint
@@ -5689,26 +5686,25 @@ def test_utf8_textdecoder(self):
     self.do_runf('benchmark/benchmark_utf8.c', 'OK.')
 
   # Test that invalid character in UTF8 does not cause decoding to crash.
-  def test_utf8_invalid(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF8ToString', 'stringToUTF8'])
-    for decoder_mode in [[], ['-sTEXTDECODER']]:
-      self.emcc_args += decoder_mode
-      print(str(decoder_mode))
-      self.do_runf('utf8_invalid.cpp', 'OK.')
+  @parameterized({
+    '': [[]],
+    'textdecoder': [['-sTEXTDECODER']],
+  })
+  def test_utf8_invalid(self, args):
+    self.do_runf('utf8_invalid.cpp', 'OK.', emcc_args=args)
 
   # Test that invalid character in UTF8 does not cause decoding to crash.
   @no_asan('TODO: ASan support in minimal runtime')
-  def test_minimal_runtime_utf8_invalid(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF8ToString', 'stringToUTF8'])
+  @parameterized({
+    '': [[]],
+    'textdecoder': [['-sTEXTDECODER']],
+  })
+  def test_minimal_runtime_utf8_invalid(self, args):
     self.set_setting('MINIMAL_RUNTIME')
     self.emcc_args += ['--pre-js', test_file('minimal_runtime_exit_handling.js')]
-    for decoder_mode in [0, 1]:
-      self.set_setting('TEXTDECODER', decoder_mode)
-      print(str(decoder_mode))
-      self.do_runf('utf8_invalid.cpp', 'OK.')
+    self.do_runf('utf8_invalid.cpp', 'OK.', emcc_args=args)
 
   def test_utf16_textdecoder(self):
-    self.set_setting('EXPORTED_RUNTIME_METHODS', ['UTF16ToString', 'stringToUTF16', 'lengthBytesUTF16'])
     self.emcc_args += ['--embed-file', test_file('utf16_corpus.txt') + '@/utf16_corpus.txt']
     self.do_runf('benchmark/benchmark_utf16.cpp', 'OK.')
 

test/utf32.cpp

@@ -12,67 +12,75 @@
 typedef unsigned int utf32;
 typedef unsigned short utf16;
 
+EM_JS_DEPS(deps, "$UTF32ToString,$stringToUTF32");
+
 // This code tests that Unicode std::wstrings can be marshalled between C++ and JS.
 int main() {
-	std::wstring wstr = L"abc\u2603\u20AC\U0002007C123 --- abc\u2603\u20AC\U0002007C123"; // U+2603 is snowman, U+20AC is the Euro sign, U+2007C is a Chinese Han character that looks like three raindrops.
+  // U+2603 is snowman,
+  // U+20AC is the Euro sign,
+  // U+2007C is a Chinese Han character that looks like three raindrops.
+  std::wstring wstr = L"abc\u2603\u20AC\U0002007C123 --- abc\u2603\u20AC\U0002007C123";
+
+  printf("sizeof(wchar_t): %d.\n", (int)sizeof(wchar_t));
 
-	printf("sizeof(wchar_t): %d.\n", (int)sizeof(wchar_t));
+  if (sizeof(wchar_t) == 4) {
+    utf32 *memory = new utf32[wstr.length()+1];
 
-	if (sizeof(wchar_t) == 4) {
-		utf32 *memory = new utf32[wstr.length()+1];
+    EM_ASM({
+      var str = UTF32ToString($0);
+      out(str);
+      var numBytesWritten = stringToUTF32(str, $1, Number($2));
+      if (numBytesWritten != 23*4) throw 'stringToUTF32 wrote an invalid length ' + numBytesWritten;
+    }, wstr.c_str(), memory, (wstr.length()+1)*sizeof(utf32));
 
-		EM_ASM({
-			var str = UTF32ToString($0);
-			out(str);
-			var numBytesWritten = stringToUTF32(str, $1, Number($2));
-			if (numBytesWritten != 23*4) throw 'stringToUTF32 wrote an invalid length ' + numBytesWritten;
-		}, wstr.c_str(), memory, (wstr.length()+1)*sizeof(utf32));
+    // Compare memory to confirm that the string is intact after taking a route
+    // through JS side.
+    const utf32 *srcPtr = reinterpret_cast<const utf32 *>(wstr.c_str());
+    for (int i = 0;; ++i) {
+      assert(memory[i] == srcPtr[i]);
+      if (srcPtr[i] == 0)
+        break;
+    }
 
-		// Compare memory to confirm that the string is intact after taking a route through JS side.
-		const utf32 *srcPtr = reinterpret_cast<const utf32 *>(wstr.c_str());
-		for(int i = 0;; ++i) {
-			assert(memory[i] == srcPtr[i]);
-			if (srcPtr[i] == 0)
-				break;
-		}
+    EM_ASM({
+      var str = UTF32ToString($0);
+      out(str);
+      var numBytesWritten = stringToUTF32(str, $1, Number($2));
+      if (numBytesWritten != 5*4) throw 'stringToUTF32 wrote an invalid length ' + numBytesWritten;
+    }, wstr.c_str(), memory, 6*sizeof(utf32));
+    assert(memory[5] == 0);
 
-		EM_ASM({
-			var str = UTF32ToString($0);
-			out(str);
-			var numBytesWritten = stringToUTF32(str, $1, Number($2));
-			if (numBytesWritten != 5*4) throw 'stringToUTF32 wrote an invalid length ' + numBytesWritten;
-		}, wstr.c_str(), memory, 6*sizeof(utf32));
-		assert(memory[5] == 0);
+    delete[] memory;
+  } else {
+    // sizeof(wchar_t) == 2, and we're building with -fshort-wchar.
+    utf16 *memory = new utf16[2*wstr.length()+1];
 
-		delete[] memory;
-	} else { // sizeof(wchar_t) == 2, and we're building with -fshort-wchar.
-		utf16 *memory = new utf16[2*wstr.length()+1];
+    EM_ASM({
+      var str = UTF16ToString($0);
+      out(str);
+      var numBytesWritten = stringToUTF16(str, $1, $2);
+      if (numBytesWritten != 25*2) throw 'stringToUTF16 wrote an invalid length ' + numBytesWritten;
+    }, wstr.c_str(), memory, (2*wstr.length()+1)*sizeof(utf16));
 
-		EM_ASM({
-			var str = UTF16ToString($0);
-			out(str);
-			var numBytesWritten = stringToUTF16(str, $1, $2);
-			if (numBytesWritten != 25*2) throw 'stringToUTF16 wrote an invalid length ' + numBytesWritten;
-		}, wstr.c_str(), memory, (2*wstr.length()+1)*sizeof(utf16));
+    // Compare memory to confirm that the string is intact after taking a route
+    // through JS side.
+    const utf16 *srcPtr = reinterpret_cast<const utf16 *>(wstr.c_str());
+    for (int i = 0;; ++i) {
+      assert(memory[i] == srcPtr[i]);
+      if (srcPtr[i] == 0)
+        break;
+    }
 
-		// Compare memory to confirm that the string is intact after taking a route through JS side.
-		const utf16 *srcPtr = reinterpret_cast<const utf16 *>(wstr.c_str());
-		for(int i = 0;; ++i) {
-			assert(memory[i] == srcPtr[i]);
-			if (srcPtr[i] == 0)
-				break;
-		}
+    EM_ASM({
+      var str = UTF16ToString($0);
+      out(str);
+      var numBytesWritten = stringToUTF16(str, $1, $2);
+      if (numBytesWritten != 5*2) throw 'stringToUTF16 wrote an invalid length ' + numBytesWritten;
+    }, wstr.c_str(), memory, 6*sizeof(utf16));
+    assert(memory[5] == 0);
 
-		EM_ASM({
-			var str = UTF16ToString($0);
-			out(str);
-			var numBytesWritten = stringToUTF16(str, $1, $2);
-			if (numBytesWritten != 5*2) throw 'stringToUTF16 wrote an invalid length ' + numBytesWritten;
-		}, wstr.c_str(), memory, 6*sizeof(utf16));
-		assert(memory[5] == 0);
-		
-		delete[] memory;
-	}
+    delete[] memory;
+  }
 
-	printf("OK.\n");
+  printf("OK.\n");
 }

test/utf8.cpp

@@ -10,6 +10,8 @@
 #include <cassert>
 #include <emscripten.h>
 
+EM_JS_DEPS(deps, "$UTF8ToString,$stringToUTF8,$AsciiToString,$stringToAscii");
+
 // This code tests that Unicode std::wstrings can be marshalled between C++ and JS.
 int main() {
   const char latin1String[] = "\x26\xA0\xF7";
@@ -45,9 +47,11 @@ int main() {
     if (numBytesWritten != 69) throw 'stringToUTF8 wrote an invalid length ' + numBytesWritten;
   }, utf8String, utf8String2, 128);
   assert(strlen(utf8String) == strlen(utf8String2));
-  for(int i = 0; i < strlen(utf8String)+1; ++i)
-    if (utf8String[i] != utf8String2[i])
+  for (int i = 0; i < strlen(utf8String)+1; ++i) {
+    if (utf8String[i] != utf8String2[i]) {
       printf("i=%d:%u,%u\n", i, (unsigned int)(unsigned char)utf8String[i], (unsigned int)(unsigned char)utf8String2[i]);
+    }
+  }
   assert(!strcmp(utf8String, utf8String2));
 
   // Test that text gets properly cut off if output buffer is too small.

test/utf8_invalid.cpp

@@ -1,13 +1,16 @@
 #include <emscripten/emscripten.h>
 #include <stdio.h>
 
-int main()
-{
-	char ch[256] = {};
-	for(int i = 0; i < 255; ++i)
-		ch[i] = i+1;
-	int totalLen = 0;
-	for(int i = 0; i < 256; ++i)
-		totalLen += EM_ASM_INT({return UTF8ToString($0).length}, ch);
-	printf("OK. Length: %d\n", totalLen);
+EM_JS_DEPS(deps, "$UTF8ToString");
+
+int main() {
+  char ch[256] = {};
+  for (int i = 0; i < 255; ++i) {
+    ch[i] = i+1;
+  }
+  int totalLen = 0;
+  for (int i = 0; i < 256; ++i) {
+    totalLen += EM_ASM_INT({return UTF8ToString($0).length}, ch);
+  }
+  printf("OK. Length: %d\n", totalLen);
 }