# Copyright 2013 The Emscripten Authors. All rights reserved.

# Emscripten is available under two separate licenses, the MIT license and the

# University of Illinois/NCSA Open Source License. Both these licenses can be

# found in the LICENSE file.

import json

import logging

import os

import platform

import random

import re

import shutil

import time

from functools import wraps

from pathlib import Path

if __name__ == '__main__':

raise Exception('do not run this file directly; do something like: test/runner')

import clang_native

import common

from common import (

EMBUILDER,

NON_ZERO,

PYTHON,

WEBIDL_BINDER,

RunnerCore,

compiler_for,

copy_asset,

create_file,

engine_is_bun,

engine_is_node,

engine_is_v8,

env_modify,

get_nodejs,

path_from_root,

read_binary,

read_file,

test_file,

)

from decorators import (

all_engines,

also_with_minimal_runtime,

also_with_modularize,

also_with_nodefs,

also_with_nodefs_both,

also_with_noderawfs,

also_with_pthreads,

also_with_standalone_wasm,

also_with_wasmfs,

also_without_bigint,

can_do_standalone,

crossplatform,

disabled,

flaky,

is_slow_test,

needs_make,

no_2gb,

no_4gb,

no_bun,

no_deno,

no_highmem,

no_wasm64,

no_windows,

parameterize,

parameterized,

requires_dev_dependency,

requires_jspi,

requires_native_clang,

requires_node,

requires_node_25,

requires_pthreads,

requires_wasm2js,

requires_wasm_eh,

skip_if,

with_all_eh_sjlj,

with_all_fs,

with_all_sjlj,

with_env_modify,

)

from tools import building, config, shared, utils, webassembly

from tools.shared import EMAR, EMCC, EMXX, FILE_PACKAGER, LLVM_COV, LLVM_PROFDATA, PIPE

from tools.utils import LINUX, MACOS, WINDOWS, delete_file, write_file

# decorators for limiting which modes a test can run in

logger = logging.getLogger("test_core")

EM_SIGINT = 2

EM_SIGABRT = 6

def esm_integration(func):

assert callable(func)

@wraps(func)

@no_sanitize('sanitizers do not support WASM_ESM_INTEGRATION')

def decorated(self, *args, **kwargs):

self.setup_esm_integration()

return func(self, *args, **kwargs)

return decorated

def no_modularize_instance(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.get_setting('MODULARIZE') == 'instance' or self.get_setting('WASM_ESM_INTEGRATION'):

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_esm_integration(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.get_setting('WASM_ESM_INTEGRATION'):

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def wasm_simd(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.is_wasm2js():

self.skipTest('wasm2js only supports MVP for now')

if '-O3' in self.cflags:

self.skipTest('SIMD tests are too slow with -O3 in the new LLVM pass manager, https://github.com/emscripten-core/emscripten/issues/13427')

self.cflags += ['-msimd128', '-fno-lax-vector-conversions']

return func(self, *args, **kwargs)

return decorated

def asan(func):

assert callable(func)

@wraps(func)

@no_safe_heap('asan does not work with SAFE_HEAP')

@no_wasm2js('TODO: ASAN in wasm2js')

@no_wasm64('TODO: ASAN in memory64')

@no_highmem("asan doesn't support GLOBAL_BASE")

def decorated(self, *args, **kwargs):

return func(self, *args, **kwargs)

return decorated

def requires_wasm_workers(func):

assert callable(func)

@wraps(func)

@no_esm_integration('WASM_ESM_INTEGRATION is not compatible with WASM_WORKERS')

@no_sanitize('sanitizers do not support WASM_WORKERS')

def decorated(self, *args, **kwargs):

return func(self, *args, **kwargs)

return decorated

def wasm_relaxed_simd(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.get_setting('MEMORY64') == 2:

self.skipTest('https://github.com/WebAssembly/binaryen/issues/4638')

# We don't actually run any tests yet, so don't require any engines.

if self.is_wasm2js():

self.skipTest('wasm2js only supports MVP for now')

self.cflags.append('-mrelaxed-simd')

return func(self, *args, **kwargs)

return decorated

def needs_non_trapping_float_to_int(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.is_wasm2js():

self.skipTest('wasm2js only supports MVP for now')

return func(self, *args, **kwargs)

return decorated

def needs_dylink(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

self.check_dylink()

return func(self, *args, **kwargs)

return decorated

def requires_x64_cpu(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if platform.machine().lower() not in {'x86_64', 'amd64'}:

return self.skipTest(f'This test requires a native x64 CPU. Current CPU is {platform.machine()}.')

return func(self, *args, **kwargs)

return decorated

def with_dylink_reversed(func):

assert callable(func)

@wraps(func)

def decorated(self, dylink_reversed, *args, **kwargs):

self.dylink_reversed = dylink_reversed

self.check_dylink()

return func(self, *args, **kwargs)

parameterize(decorated, {'': (False,),

'reversed': (True,)})

return decorated

no_wasm2js = skip_if('no_wasm2js', lambda t: t.is_wasm2js())

# Some tests are marked as only-wasm2js because they test basic codegen in a way

# that is mainly useful for the wasm2js compiler and not LLVM. LLVM tests its

# own codegen, while wasm2js testing is split between the binaryen repo (which

# tests wat files) and this repo (which tests C/C++ files).

#

# Note that some tests here may seem excessive, e.g., testing 16-bit math, as

# LLVM turns those things into i32 values in wasm anyhow before wasm2js.

# However, it is still useful to test wasm2js there as LLVM emits patterns of

# shifts and such around those values to ensure they operate as 16-bit, and we

# want coverage of that.

only_wasm2js = skip_if('only_wasm2js', lambda t: not t.is_wasm2js())

def with_asyncify_and_jspi(func):

assert callable(func)

@wraps(func)

def metafunc(self, jspi, *args, **kwargs):

if self.get_setting('WASM_ESM_INTEGRATION'):

self.skipTest('WASM_ESM_INTEGRATION is not compatible with ASYNCIFY')

if jspi:

self.set_setting('JSPI')

self.require_jspi()

else:

self.set_setting('ASYNCIFY')

return func(self, *args, **kwargs)

parameterize(metafunc, {'': (False,),

'jspi': (True,)})

return metafunc

def also_with_asyncify_and_jspi(func):

assert callable(func)

@wraps(func)

def metafunc(self, asyncify, *args, **kwargs):

if asyncify and self.get_setting('WASM_ESM_INTEGRATION'):

self.skipTest('WASM_ESM_INTEGRATION is not compatible with ASYNCIFY')

if asyncify == 2:

self.set_setting('JSPI')

self.require_jspi()

elif asyncify == 1:

self.set_setting('ASYNCIFY')

else:

assert asyncify == 0

return func(self, *args, **kwargs)

parameterize(metafunc, {'': (0,),

'asyncify': (1,),

'jspi': (2,)})

return metafunc

def also_with_wasm_workers(func):

assert callable(func)

@wraps(func)

def metafunc(self, ww, *args, **kwargs):

f = func

if ww:

f = requires_wasm_workers(f)

self.cflags += ['-sWASM_WORKERS']

return f(self, *args, **kwargs)

parameterize(metafunc, {'': (False,), 'ww': (True,)})

return metafunc

def no_optimize(note=''):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.is_optimizing():

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_asan(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if '-fsanitize=address' in self.cflags:

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_lsan(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if '-fsanitize=leak' in self.cflags:

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_ubsan(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if '-fsanitize=undefined' in self.cflags:

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_sanitize(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if any(a.startswith('-fsanitize=') for a in self.cflags):

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def no_wasmfs(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if self.get_setting('WASMFS'):

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

def make_no_decorator_for_setting(name):

def outer_decorator(note):

assert not callable(note)

def decorator(func):

assert callable(func)

@wraps(func)

def decorated(self, *args, **kwargs):

if '=' in name:

key, val = name.split('=', 1)

else:

key = name

val = 1

if int(val) == 1 and f'-s{key}' in self.cflags:

self.skipTest(note)

if f'-s{key}={val}' in self.cflags or self.get_setting(key) == int(val):

self.skipTest(note)

return func(self, *args, **kwargs)

return decorated

return decorator

return outer_decorator

def with_both_text_decoder(func):

assert callable(func)

@wraps(func)

def decorated(self, textdecoder, *args, **kwargs):

self.set_setting('TEXTDECODER', textdecoder)

return func(self, *args, **kwargs)

parameterize(decorated, {'': (1,), 'force_textdecoder': (2,)})

return decorated

no_safe_heap = make_no_decorator_for_setting('SAFE_HEAP')

no_strict = make_no_decorator_for_setting('STRICT')

no_strict_js = make_no_decorator_for_setting('STRICT_JS')

no_big_endian = make_no_decorator_for_setting('SUPPORT_BIG_ENDIAN')

no_omit_asm_module_exports = make_no_decorator_for_setting('DECLARE_ASM_MODULE_EXPORTS=0')

no_js_math = make_no_decorator_for_setting('JS_MATH')

def is_sanitizing(args):

return '-fsanitize=' in str(args)

class TestCoreBase(RunnerCore):

@classmethod

def setUpClass(cls):

"""SetUpClass included purely so we can verify that is run."""

super().setUpClass()

cls.doneSetup = True

# A simple check whether the compiler arguments cause optimization.

def is_optimizing(self):

return '-O' in str(self.cflags) and '-O0' not in self.cflags

def should_use_closure(self):

# Don't run closure in all test modes, just a couple, since it slows

# the tests down quite a bit.

required = ('-O2', '-Os')

prohibited = ('-g', '--profiling')

return all(f not in self.cflags for f in prohibited) and any(f in self.cflags for f in required)

def setup_esm_integration(self):

self.require_node_25()

# Using instance phase imports current generates am ExperimentalWarning under node.

self.node_args += ['--no-warnings']

self.set_setting('WASM_ESM_INTEGRATION')

self.cflags += ['-Wno-experimental']

if self.is_wasm64():

self.skipTest('wasm64 requires wasm export wrappers')

if self.is_wasm2js():

self.skipTest('WASM_ESM_INTEGRATION is not compatible with wasm2js')

# Use closure in some tests for some additional coverage

def maybe_closure(self):

if '--closure=1' not in self.cflags and self.should_use_closure():

self.cflags += ['--closure=1']

logger.debug('using closure compiler..')

return True

return False

def assertStartswith(self, output, prefix):

self.assertEqual(prefix, output[:len(prefix)])

def verify_in_strict_mode(self, filename):

js = read_file(filename)

base, ext = os.path.split(filename)

strict_filename = base + '.strict' + ext

write_file(strict_filename, '"use strict";\n' + js)

self.run_js(strict_filename)

def do_core_test(self, testname, **kwargs):

self.do_run_in_out_file_test(Path('core', testname), **kwargs)

def get_bullet_library(self, use_cmake):

if use_cmake:

configure_commands = ['cmake', '.']

configure_args = ['-DBUILD_DEMOS=OFF', '-DBUILD_EXTRAS=OFF', '-DUSE_GLUT=OFF',

'-DCMAKE_CXX_STANDARD=14']

# Depending on whether 'configure' or 'cmake' is used to build, Bullet

# places output files in different directory structures.

generated_libs = ['src/BulletDynamics/libBulletDynamics.a',

'src/BulletCollision/libBulletCollision.a',

'src/LinearMath/libLinearMath.a']

else:

configure_commands = ['sh', './configure']

# Force a nondefault --host= so that the configure script will interpret

# that we are doing cross-compilation

# and skip attempting to run the generated executable with './a.out',

# which would fail since we are building a .js file.

configure_args = ['--disable-shared', '--build=i686-pc-linux-gnu',

'--host=i686-pc-linux-gnu', '--disable-demos',

'--disable-dependency-tracking']

generated_libs = ['src/.libs/libBulletDynamics.a',

'src/.libs/libBulletCollision.a',

'src/.libs/libLinearMath.a']

return self.get_library('third_party/bullet', generated_libs,

configure=configure_commands,

configure_args=configure_args,

cache_name_extra=configure_commands[0])

@crossplatform

def test_hello_world(self):

self.do_core_test('test_hello_world.c')

@no_esm_integration('WASM_ASYNC_COMPILATION=0')

def test_wasm_synchronous_compilation(self):

if self.get_setting('MODULARIZE') != 'instance':

self.set_setting('STRICT_JS')

self.set_setting('WASM_ASYNC_COMPILATION', 0)

self.do_core_test('test_hello_world.c')

@also_with_standalone_wasm()

def test_hello_argc(self):

self.do_core_test('test_hello_argc.c', args=['hello', 'world'])

@crossplatform

@requires_pthreads

def test_hello_argc_pthreads(self):

self.set_setting('PROXY_TO_PTHREAD')

self.set_setting('EXIT_RUNTIME')

self.do_core_test('test_hello_argc.c', args=['hello', 'world'])

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_intvars(self):

self.do_core_test('test_intvars.cpp')

def test_int53(self):

if common.EMTEST_REBASELINE:

ret = self.do_runf('core/test_int53.c', interleaved_output=False, cflags=['-DGENERATE_ANSWERS'])

write_file(test_file('core/test_int53.out'), ret)

else:

self.do_core_test('test_int53.c', interleaved_output=False)

def test_int53_convertI32PairToI53Checked(self):

if common.EMTEST_REBASELINE:

ret = self.do_runf('core/test_convertI32PairToI53Checked.cpp', interleaved_output=False, cflags=['-DGENERATE_ANSWERS'])

write_file(test_file('core/test_convertI32PairToI53Checked.out'), ret)

else:

self.do_core_test('test_convertI32PairToI53Checked.cpp', interleaved_output=False)

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64(self):

# test shifts etc. on 64-bit integers as well as printf() on them. we need

# the math testing only for wasm2js but do not apply @only_wasm2js since we

# do want some testing of 64-bit printf in our libc (which is not tested in

# clang upstream).

self.do_core_test('test_i64.c')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_2(self):

self.do_core_test('test_i64_2.cpp')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_3(self):

self.do_core_test('test_i64_3.cpp')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_4(self):

# stuff that also needs sign corrections

self.do_core_test('test_i64_4.c')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_b(self):

self.do_core_test('test_i64_b.cpp')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_cmp(self):

self.do_core_test('test_i64_cmp.cpp')

@only_wasm2js('test shifts etc. on 64-bit integers')

def test_i64_cmp2(self):

self.do_core_test('test_i64_cmp2.c')

@only_wasm2js('test unions of i64 and double')

def test_i64_double(self):

self.do_core_test('test_i64_double.cpp')

@only_wasm2js('test 64-bit multiply')

def test_i64_umul(self):

self.do_core_test('test_i64_umul.c')

@only_wasm2js('test 64-bit math')

@also_with_standalone_wasm()

@no_ubsan('contains UB')

def test_i64_precise(self):

self.do_core_test('test_i64_precise.c')

@only_wasm2js('test 64-bit multiply')

def test_i64_precise_needed(self):

self.do_core_test('test_i64_precise_needed.c')

def test_i64_llabs(self):

# test the libc llabs() method

self.do_core_test('test_i64_llabs.c')

def test_i64_zextneg(self):

# test zero/sign-extension in printf arguments

self.do_core_test('test_i64_zextneg.c')

@only_wasm2js('test 64-bit math')

def test_i64_7z(self):

self.do_core_test('test_i64_7z.c', args=['hallo'])

@only_wasm2js('test 64-bit math with short values')

def test_i64_i16(self):

self.do_core_test('test_i64_i16.c')

@only_wasm2js('test 64-bit/double conversions')

def test_i64_qdouble(self):

self.do_core_test('test_i64_qdouble.c')

@only_wasm2js('tests va_arg() with i64 params')

def test_i64_varargs(self):

self.do_core_test('test_i64_varargs.c', args='waka fleefl asdfasdfasdfasdf'.split())

@no_wasm2js('wasm_bigint')

@requires_node

def test_i64_invoke_bigint(self):

self.do_core_test('test_i64_invoke_bigint.cpp', cflags=['-fexceptions'])

@only_wasm2js('tests va_arg()')

def test_vararg_copy(self):

self.do_run_in_out_file_test('va_arg/test_va_copy.c')

def test_llvm_fabs(self):

self.do_core_test('test_llvm_fabs.c')

@only_wasm2js('tests va_arg()')

def test_double_varargs(self):

self.do_core_test('test_double_varargs.c')

@only_wasm2js('tests va_arg()')

def test_trivial_struct_varargs(self):

self.do_core_test('test_trivial_struct_varargs.c')

@only_wasm2js('tests va_arg()')

def test_struct_varargs(self):

self.do_core_test('test_struct_varargs.c')

@only_wasm2js('tests va_arg()')

def test_zero_struct_varargs(self):

self.do_core_test('test_zero_struct_varargs.c')

@only_wasm2js('tests va_arg()')

def test_nested_struct_varargs(self):

self.do_core_test('test_nested_struct_varargs.c')

@only_wasm2js('tests 32-bit multiplication')

def test_i32_mul_precise(self):

self.do_core_test('test_i32_mul_precise.c')

@only_wasm2js('tests operations on 16-bit values')

def test_i16_emcc_intrinsic(self):

self.do_core_test('test_i16_emcc_intrinsic.c')

@only_wasm2js('tests 64-bit conversions')

def test_double_i64_conversion(self):

self.do_core_test('test_double_i64_conversion.c')

@only_wasm2js('tests float32 ops')

def test_float32_precise(self):

self.do_core_test('test_float32_precise.c')

def test_negative_zero(self):

self.do_core_test('test_negative_zero.c')

def test_literal_negative_zero(self):

self.do_core_test('test_literal_negative_zero.c')

@only_wasm2js('tests byte conversions')

@also_with_standalone_wasm()

def test_bswap64(self):

self.do_core_test('test_bswap64.cpp')

def test_sha1(self):

self.do_runf('third_party/sha1.c', 'SHA1=15dd99a1991e0b3826fede3deffc1feba42278e6')

def test_core_types(self):

self.do_runf('core/test_core_types.c')

def test_cube2md5(self):

copy_asset('core/test_cube2md5.txt')

self.do_core_test('test_cube2md5.c', cflags=['--embed-file', 'test_cube2md5.txt'])

@also_with_standalone_wasm()

@needs_make('make')

def test_cube2hash(self):

# A good test of i64 math

self.do_run('// empty file', 'Usage: hashstring <seed>',

libraries=self.get_library('third_party/cube2hash', ['libcube2hash.a'], configure=None),

includes=[test_file('third_party/cube2hash')], assert_returncode=NON_ZERO)

js_out = self.output_name('src')

for text, output in [('fleefl', '892BDB6FD3F62E863D63DA55851700FDE3ACF30204798CE9'),

('fleefl2', 'AA2CC5F96FC9D540CA24FDAF1F71E2942753DB83E8A81B61'),

('64bitisslow', '64D8470573635EC354FEE7B7F87C566FCAF1EFB491041670')]:

self.do_run(js_out, 'hash value: ' + output, args=[text], no_build=True)

@only_wasm2js('tests 64-bit alignment of structs')

def test_align64(self):

src = r'''

#include <stdio.h>

// inspired by poppler

enum Type {

A = 10,

B = 20

};

struct Object {

Type type;

union {

int intg;

double real;

char *name;

};

};

struct Principal {

double x;

Object a;

double y;

};

int main(int argc, char **argv) {

int base = argc-1;

Object o[10];

printf("%zu,%zu\n", sizeof(Object), sizeof(Principal));

printf("%ld,%ld,%ld,%ld\n", (long)&o[base].type - (long)o, (long)&o[base].intg - (long)o, (long)&o[base].real - (long)o, (long)&o[base].name - (long)o);

printf("%ld,%ld,%ld,%ld\n", (long)&o[base+1].type - (long)o, (long)&o[base+1].intg - (long)o, (long)&o[base+1].real - (long)o, (long)&o[base+1].name - (long)o);

Principal p, q;

p.x = p.y = q.x = q.y = 0;

p.a.type = A;

p.a.real = 123.456;

*(&q.a) = p.a;

printf("%.2f,%d,%.2f,%.2f : %.2f,%d,%.2f,%.2f\n", p.x, p.a.type, p.a.real, p.y, q.x, q.a.type, q.a.real, q.y);

return 0;

}

'''

self.do_run(src, '''16,32

0,8,8,8

16,24,24,24

0.00,10,123.46,0.00 : 0.00,10,123.46,0.00

''')

@only_wasm2js('tests signed vs unsigned values')

def test_unsigned(self):

src = '''

#include <stdio.h>

const signed char cvals[2] = { -1, -2 }; // compiler can store this as a string, so -1 becomes \\FF, and needs re-signing

int main()

{

{

unsigned char x = 200;

printf("*%d*\\n", x);

unsigned char y = -22;

printf("*%d*\\n", y);

}

int varey = 100;

unsigned int MAXEY = -1, MAXEY2 = -77;

printf("*%u,%d,%u*\\n", MAXEY, varey >= MAXEY, MAXEY2); // 100 >= -1? not in unsigned!

int y = cvals[0];

printf("*%d,%d,%d,%d*\\n", cvals[0], cvals[0] < 0, y, y < 0);

y = cvals[1];

printf("*%d,%d,%d,%d*\\n", cvals[1], cvals[1] < 0, y, y < 0);

// zext issue - see mathop in jsifier

unsigned char x8 = -10;

unsigned long hold = 0;

hold += x8;

int y32 = hold+50;

printf("*%lu,%d*\\n", hold, y32);

// Comparisons

x8 = 0;

for (int i = 0; i < 254; i++) x8++; // make it an actual 254 in JS - not a -2

printf("*%d,%d*\\n", x8+1 == 0xff, x8+1 != 0xff); // 0xff may be '-1' in the bitcode

return 0;

}

'''

self.do_run(src, '*4294967295,0,4294967219*\n*-1,1,-1,1*\n*-2,1,-2,1*\n*246,296*\n*1,0*')

src = '''

#include <stdio.h>

int main()

{

{

unsigned char x;

unsigned char *y = &x;

*y = -1;

printf("*%d*\\n", x);

}

{

unsigned short x;

unsigned short *y = &x;

*y = -1;

printf("*%d*\\n", x);

}

/*{ // This case is not checked. The hint for unsignedness is just the %u in printf, and we do not analyze that

unsigned int x;

unsigned int *y = &x;

*y = -1;

printf("*%u*\\n", x);

}*/

{

char x;

char *y = &x;

*y = 255;

printf("*%d*\\n", x);

}

{

char x;

char *y = &x;

*y = 65535;

printf("*%d*\\n", x);

}

{

char x;

char *y = &x;

*y = 0xffffffff;

printf("*%d*\\n", x);

}

return 0;

}

'''

self.do_run(src, '*255*\n*65535*\n*-1*\n*-1*\n*-1*', cflags=['-Wno-constant-conversion'])

@only_wasm2js('tests 1-bit fields')

def test_bitfields(self):

self.do_core_test('test_bitfields.c')

def test_floatvars(self):

self.do_core_test('test_floatvars.cpp')

@only_wasm2js('tests pointer casts')

def test_closebitcasts(self):

self.do_core_test('closebitcasts.c')

def test_fast_math(self):

self.do_core_test('test_fast_math.c', args=['5', '6', '8'], cflags=['-ffast-math'])

@only_wasm2js('tests division by zero')

def test_zerodiv(self):

self.do_core_test('test_zerodiv.c')

@only_wasm2js('tests multiplication by zero')

def test_zero_multiplication(self):

self.do_core_test('test_zero_multiplication.c')

def test_isnan(self):

self.do_core_test('test_isnan.c')

@only_wasm2js('tests globals in static data')

def test_globaldoubles(self):

self.do_core_test('test_globaldoubles.c')

def test_math(self):

self.do_core_test('test_math.c')

@only_wasm2js('tests lgamma and signbit')

def test_math_lgamma(self):

self.do_run_in_out_file_test('math/lgamma.c', assert_returncode=NON_ZERO)

@only_wasm2js('tests fmodf (which may use JS math)')

def test_math_fmodf(self):

self.do_run_in_out_file_test('math/fmodf.c')

def test_rounding(self):

self.do_core_test('test_rounding.c')

def test_stack(self):

self.set_setting('INLINING_LIMIT')

# some extra coverage in all test suites for stack checks

self.set_setting('STACK_OVERFLOW_CHECK', 2)

self.do_core_test('test_stack.c')

def test_stack_align(self):

self.do_core_test('test_stack_align.c')

@no_asan('stack size is too low for asan to work properly')

def test_stack_placement(self):

self.set_setting('STACK_SIZE', 1024)

self.do_core_test('test_stack_placement.c')

self.set_setting('GLOBAL_BASE', '100kb')

self.do_core_test('test_stack_placement.c')

@no_sanitize('sanitizers do not yet support dynamic linking')

@no_wasm2js('MAIN_MODULE support')

@needs_dylink

@no_js_math('JS_MATH is not compatible with MAIN_MODULE=1')

def test_stack_placement_pic(self):

self.set_setting('STACK_SIZE', 1024)

self.set_setting('MAIN_MODULE')

self.do_core_test('test_stack_placement.c')

self.set_setting('GLOBAL_BASE', '100kb')

self.do_core_test('test_stack_placement.c')

def test_mainenv(self):

self.do_core_test('test_mainenv.c')

@no_asan('ASan does not support custom memory allocators')

@no_lsan('LSan does not support custom memory allocators')

@parameterized({

'normal': [],

'memvalidate': ['-DEMMALLOC_MEMVALIDATE'],

'memvalidate_verbose': ['-DEMMALLOC_MEMVALIDATE', '-DEMMALLOC_VERBOSE', '-DRANDOM_ITERS=130'],

})

def test_emmalloc(self, *args):

self.maybe_closure()

# in newer clang+llvm, the internal calls to malloc in emmalloc may be optimized under

# the assumption that they are external, so like in system_libs.py where we build

# malloc, we need to disable builtin here too

self.set_setting('MALLOC', 'none')

self.cflags += [

'-fno-builtin',

path_from_root('system/lib/libc/sbrk.c'),

path_from_root('system/lib/emmalloc.c'),

]

self.do_core_test('test_emmalloc.c', cflags=args)

@no_asan('ASan does not support custom memory allocators')

@no_lsan('LSan does not support custom memory allocators')

def test_emmalloc_usable_size(self):

self.set_setting('MALLOC', 'emmalloc')

self.do_core_test('test_malloc_usable_size.c', regex=True)

@no_asan('ASan does not support custom memory allocators')

@no_lsan('LSan does not support custom memory allocators')

@no_highmem('uses INITIAL_MEMORY')

def test_emmalloc_memory_statistics(self):

self.set_setting('MALLOC', 'emmalloc')

self.set_setting('INITIAL_MEMORY', '128MB')

output = self.do_runf('test_emmalloc_memory_statistics.c')

self.assertContained('valid allocs: 1', output)

self.assertContained('emmalloc_validate_memory_regions: 0', output)

self.assertContained(r'emmalloc_dynamic_heap_size\s*: [1-9]\d+', output, regex=True)

self.assertContained(r'emmalloc_free_dynamic_memory\s*: [1-9]\d+', output, regex=True)

self.assertContained(r'numFreeMemoryRegions\s*: [1-9]+', output, regex=True)

self.assertContained(r'Free memory regions of size \[\d+,\d+\[ bytes: 1 regions', output, regex=True)

self.assertContained(r'emmalloc_unclaimed_heap_memory\s*: [1-9]\d+', output, regex=True)

@no_optimize('output is sensitive to optimization flags, so only test unoptimized builds')

@no_highmem('output is sensitive to absolute data layout')

@no_asan('ASan does not support custom memory allocators')

@no_lsan('LSan does not support custom memory allocators')

def test_emmalloc_trim(self):

self.set_setting('MALLOC', 'emmalloc')

self.do_core_test('test_emmalloc_trim.c', cflags=['-sINITIAL_MEMORY=128MB', '-sALLOW_MEMORY_GROWTH', '-sMAXIMUM_MEMORY=2147418112'])

# Test case against https://github.com/emscripten-core/emscripten/issues/10363

def test_emmalloc_memalign_corruption(self):

self.set_setting('MALLOC', 'emmalloc')

self.do_core_test('test_emmalloc_memalign_corruption.c')

@also_with_standalone_wasm()

def test_assert(self):

self.do_core_test('test_assert.c', assert_returncode=NON_ZERO)

@crossplatform

@also_with_standalone_wasm(impure=True)

def test_longjmp_standalone(self):

self.do_core_test('test_longjmp.c')

@with_all_sjlj