3d34a91f0b
Implement the first version of Python language binding Co-authored-by: liang.he <liang.he@intel.com>
526 lines
18 KiB
Python
526 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
|
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (C) 2019 Intel Corporation. All rights reserved.
|
|
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
#
|
|
# pylint: disable=missing-class-docstring
|
|
# pylint: disable=missing-function-docstring
|
|
# pylint: disable=missing-module-docstring
|
|
|
|
import ctypes as c
|
|
import math
|
|
import unittest
|
|
|
|
import wamr.ffi as ffi
|
|
|
|
|
|
# It is a module likes:
|
|
# (module
|
|
# (import "mod" "g0" (global i32))
|
|
# (import "mod" "f0" (func (param f32) (result f64)))
|
|
#
|
|
# (func (export "f1") (param i32 i64))
|
|
# (global (export "g1") (mut f32) (f32.const 3.14))
|
|
# (memory (export "m1") 1 2)
|
|
# (table (export "t1") 1 funcref)
|
|
#
|
|
# (func (export "f2") (unreachable))
|
|
# )
|
|
MODULE_BINARY = (
|
|
b"\x00asm\x01\x00\x00\x00\x01\x0e\x03`\x01}\x01|`\x02\x7f~\x00`\x00"
|
|
b"\x00\x02\x14\x02\x03mod\x02g0\x03\x7f\x00\x03mod\x02f0\x00\x00\x03\x03"
|
|
b"\x02\x01\x02\x04\x04\x01p\x00\x01\x05\x04\x01\x01\x01\x02\x06\t\x01}\x01C"
|
|
b"\xc3\xf5H@\x0b\x07\x1a\x05\x02f1\x00\x01\x02g1\x03\x01\x02m1\x02\x00\x02t1"
|
|
b"\x01\x00\x02f2\x00\x02\n\x08\x02\x02\x00\x0b\x03\x00\x00\x0b"
|
|
)
|
|
|
|
# False -> True when testing with a library enabling WAMR_BUILD_DUMP_CALL_STACK flag
|
|
TEST_WITH_WAMR_BUILD_DUMP_CALL_STACK = False
|
|
|
|
|
|
@ffi.wasm_func_cb_decl
|
|
def callback(args, results):
|
|
args = ffi.dereference(args)
|
|
results = ffi.dereference(results)
|
|
|
|
arg_v = args.data[0]
|
|
|
|
result_v = ffi.wasm_f64_val(arg_v.of.f32 * 2.0)
|
|
ffi.wasm_val_copy(results.data[0], result_v)
|
|
results.num_elems = 1
|
|
|
|
print(f"\nIn callback: {arg_v} --> {result_v}\n")
|
|
|
|
|
|
@ffi.wasm_func_with_env_cb_decl
|
|
def callback_with_env(env, args, results):
|
|
# pylint: disable=unused-argument
|
|
print("summer")
|
|
|
|
|
|
class AdvancedTestSuite(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
print("Initializing...")
|
|
cls._wasm_engine = ffi.wasm_engine_new()
|
|
cls._wasm_store = ffi.wasm_store_new(cls._wasm_engine)
|
|
|
|
def assertIsNullPointer(self, pointer):
|
|
# pylint: disable=invalid-name
|
|
if not ffi.is_null_pointer(pointer):
|
|
self.fail("not a non-null pointer")
|
|
|
|
def assertIsNotNullPointer(self, pointer):
|
|
# pylint: disable=invalid-name
|
|
if ffi.is_null_pointer(pointer):
|
|
self.fail("not a non-null pointer")
|
|
|
|
def load_binary(self, binary_string):
|
|
print("Load binary...")
|
|
binary = ffi.load_module_file(binary_string)
|
|
binary = c.pointer(binary)
|
|
self.assertIsNotNullPointer(binary)
|
|
return binary
|
|
|
|
def compile(self, binary):
|
|
print("Compile...")
|
|
module = ffi.wasm_module_new(self._wasm_store, binary)
|
|
self.assertIsNotNullPointer(module)
|
|
return module
|
|
|
|
def prepare_imports_local(self):
|
|
print("Prepare imports...")
|
|
func_type = ffi.wasm_functype_new_1_1(
|
|
ffi.wasm_valtype_new(ffi.WASM_F32),
|
|
ffi.wasm_valtype_new(ffi.WASM_F64),
|
|
)
|
|
func = ffi.wasm_func_new(self._wasm_store, func_type, callback)
|
|
self.assertIsNotNullPointer(func)
|
|
ffi.wasm_functype_delete(func_type)
|
|
|
|
glbl_type = ffi.wasm_globaltype_new(ffi.wasm_valtype_new(ffi.WASM_I32), True)
|
|
init = ffi.wasm_i32_val(1024)
|
|
glbl = ffi.wasm_global_new(self._wasm_store, glbl_type, init)
|
|
self.assertIsNotNullPointer(glbl)
|
|
ffi.wasm_globaltype_delete(glbl_type)
|
|
|
|
imports = ffi.wasm_extern_vec_t()
|
|
data = ffi.list_to_carray(
|
|
c.POINTER(ffi.wasm_extern_t),
|
|
ffi.wasm_func_as_extern(func),
|
|
ffi.wasm_global_as_extern(glbl),
|
|
)
|
|
ffi.wasm_extern_vec_new(imports, 2, data)
|
|
imports = c.pointer(imports)
|
|
self.assertIsNotNullPointer(imports)
|
|
return imports
|
|
|
|
def instantiate(self, module, imports):
|
|
print("Instantiate module...")
|
|
instance = ffi.wasm_instance_new(
|
|
self._wasm_store, module, imports, ffi.create_null_pointer(ffi.wasm_trap_t)
|
|
)
|
|
self.assertIsNotNone(instance)
|
|
self.assertIsNotNullPointer(instance)
|
|
return instance
|
|
|
|
def extract_exports(self, instance):
|
|
print("Extracting exports...")
|
|
exports = ffi.wasm_extern_vec_t()
|
|
ffi.wasm_instance_exports(instance, exports)
|
|
exports = c.pointer(exports)
|
|
self.assertIsNotNullPointer(exports)
|
|
return exports
|
|
|
|
def setUp(self):
|
|
binary = self.load_binary(MODULE_BINARY)
|
|
self.module = self.compile(binary)
|
|
self.imports = self.prepare_imports_local()
|
|
self.instance = self.instantiate(self.module, self.imports)
|
|
self.exports = self.extract_exports(self.instance)
|
|
|
|
ffi.wasm_byte_vec_delete(binary)
|
|
|
|
def tearDown(self):
|
|
if self.imports:
|
|
ffi.wasm_extern_vec_delete(self.imports)
|
|
|
|
if self.exports:
|
|
ffi.wasm_extern_vec_delete(self.exports)
|
|
|
|
ffi.wasm_instance_delete(self.instance)
|
|
ffi.wasm_module_delete(self.module)
|
|
|
|
def test_wasm_func_call_wasm(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
print(export_list)
|
|
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
self.assertIsNotNullPointer(func)
|
|
|
|
# make a call
|
|
params = ffi.wasm_val_vec_t()
|
|
data = ffi.list_to_carray(
|
|
ffi.wasm_val_t,
|
|
ffi.wasm_i32_val(1024),
|
|
ffi.wasm_i64_val(1024 * 1024),
|
|
)
|
|
ffi.wasm_val_vec_new(params, 2, data)
|
|
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(results)
|
|
|
|
ffi.wasm_func_call(func, params, results)
|
|
|
|
def test_wasm_func_call_native(self):
|
|
import_list = ffi.wasm_vec_to_list(self.imports)
|
|
|
|
func = ffi.wasm_extern_as_func(import_list[0])
|
|
self.assertIsNotNullPointer(func)
|
|
|
|
params = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new(
|
|
params, 1, ffi.list_to_carray(ffi.wasm_val_t, ffi.wasm_f32_val(3.14))
|
|
)
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_uninitialized(results, 1)
|
|
ffi.wasm_func_call(func, params, results)
|
|
self.assertEqual(params.data[0].of.f32 * 2, results.data[0].of.f64)
|
|
|
|
def test_wasm_func_call_wrong_params(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
# make a call
|
|
params = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(params)
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(results)
|
|
trap = ffi.wasm_func_call(func, params, results)
|
|
|
|
self.assertIsNotNullPointer(trap)
|
|
|
|
def test_wasm_func_call_unlinked(self):
|
|
ft = ffi.wasm_functype_new_0_0()
|
|
func = ffi.wasm_func_new(self._wasm_store, ft, callback)
|
|
params = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(params)
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(results)
|
|
trap = ffi.wasm_func_call(func, params, results)
|
|
ffi.wasm_func_delete(func)
|
|
|
|
def test_wasm_global_get_wasm(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
glb = ffi.wasm_extern_as_global(export_list[1])
|
|
self.assertIsNotNullPointer(glb)
|
|
|
|
# access the global
|
|
val = ffi.wasm_val_t()
|
|
ffi.wasm_global_get(glb, val)
|
|
self.assertAlmostEqual(val.of.f32, 3.14, places=3)
|
|
|
|
def test_wasm_global_get_native(self):
|
|
import_list = ffi.wasm_vec_to_list(self.imports)
|
|
|
|
glb = ffi.wasm_extern_as_global(import_list[1])
|
|
self.assertIsNotNullPointer(glb)
|
|
|
|
val = ffi.wasm_val_t()
|
|
ffi.wasm_global_get(glb, val)
|
|
self.assertEqual(val.of.i32, 1024)
|
|
|
|
def test_wasm_global_get_unlinked(self):
|
|
gt = ffi.wasm_globaltype_new(ffi.wasm_valtype_new(ffi.WASM_I32), True)
|
|
init = ffi.wasm_i32_val(32)
|
|
glbl = ffi.wasm_global_new(self._wasm_store, gt, init)
|
|
val_ret = ffi.wasm_f32_val(3.14)
|
|
ffi.wasm_global_get(glbl, val_ret)
|
|
ffi.wasm_global_delete(glbl)
|
|
|
|
# val_ret wasn't touched, keep the original value
|
|
self.assertAlmostEqual(val_ret.of.f32, 3.14, 3)
|
|
|
|
def test_wasm_global_get_null_val(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
glb = ffi.wasm_extern_as_global(export_list[1])
|
|
ffi.wasm_global_get(glb, ffi.create_null_pointer(ffi.wasm_val_t))
|
|
|
|
def test_wasm_global_get_null_global(self):
|
|
val = ffi.wasm_val_t()
|
|
ffi.wasm_global_get(ffi.create_null_pointer(ffi.wasm_global_t), val)
|
|
|
|
def test_wasm_global_set_wasm(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
glb = ffi.wasm_extern_as_global(export_list[1])
|
|
self.assertIsNotNullPointer(glb)
|
|
|
|
# access the global
|
|
new_val = ffi.wasm_f32_val(math.e)
|
|
ffi.wasm_global_set(glb, new_val)
|
|
|
|
val = ffi.wasm_val_t()
|
|
ffi.wasm_global_get(glb, val)
|
|
self.assertNotEqual(val.of.f32, 3.14)
|
|
|
|
def test_wasm_global_set_native(self):
|
|
import_list = ffi.wasm_vec_to_list(self.imports)
|
|
|
|
glb = ffi.wasm_extern_as_global(import_list[1])
|
|
self.assertIsNotNullPointer(glb)
|
|
|
|
new_val = ffi.wasm_i32_val(2048)
|
|
ffi.wasm_global_set(glb, new_val)
|
|
|
|
val = ffi.wasm_val_t()
|
|
ffi.wasm_global_get(glb, val)
|
|
self.assertEqual(val, new_val)
|
|
|
|
def test_wasm_global_set_unlinked(self):
|
|
gt = ffi.wasm_globaltype_new(ffi.wasm_valtype_new(ffi.WASM_I32), True)
|
|
init = ffi.wasm_i32_val(32)
|
|
glbl = ffi.wasm_global_new(self._wasm_store, gt, init)
|
|
val_ret = ffi.wasm_f32_val(3.14)
|
|
ffi.wasm_global_set(glbl, val_ret)
|
|
ffi.wasm_global_delete(glbl)
|
|
|
|
def test_wasm_global_set_null_v(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
glb = ffi.wasm_extern_as_global(export_list[1])
|
|
# access the global
|
|
ffi.wasm_global_set(glb, ffi.create_null_pointer(ffi.wasm_val_t))
|
|
|
|
def test_wasm_global_set_null_global(self):
|
|
# access the global
|
|
new_val = ffi.wasm_f32_val(math.e)
|
|
ffi.wasm_global_set(ffi.create_null_pointer(ffi.wasm_global_t), new_val)
|
|
|
|
def test_wasm_table_size(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
self.assertIsNotNullPointer(tbl)
|
|
|
|
tbl_sz = ffi.wasm_table_size(tbl)
|
|
self.assertEqual(tbl_sz, 1)
|
|
|
|
def test_wasm_table_size_unlink(self):
|
|
vt = ffi.wasm_valtype_new(ffi.WASM_FUNCREF)
|
|
limits = ffi.wasm_limits_new(10, 15)
|
|
tt = ffi.wasm_tabletype_new(vt, limits)
|
|
tbl = ffi.wasm_table_new(
|
|
self._wasm_store, tt, ffi.create_null_pointer(ffi.wasm_ref_t)
|
|
)
|
|
tbl_sz = ffi.wasm_table_size(tbl)
|
|
ffi.wasm_table_delete(tbl)
|
|
|
|
def test_wasm_table_size_null_table(self):
|
|
ffi.wasm_table_size(ffi.create_null_pointer(ffi.wasm_table_t))
|
|
|
|
def test_wasm_table_get(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
self.assertIsNotNullPointer(tbl)
|
|
|
|
ref = ffi.wasm_table_get(tbl, 0)
|
|
self.assertIsNullPointer(ref)
|
|
|
|
ref = ffi.wasm_table_get(tbl, 4096)
|
|
self.assertIsNullPointer(ref)
|
|
|
|
def test_wasm_table_get_unlinked(self):
|
|
vt = ffi.wasm_valtype_new(ffi.WASM_FUNCREF)
|
|
limits = ffi.wasm_limits_new(10, 15)
|
|
tt = ffi.wasm_tabletype_new(vt, limits)
|
|
tbl = ffi.wasm_table_new(
|
|
self._wasm_store, tt, ffi.create_null_pointer(ffi.wasm_ref_t)
|
|
)
|
|
ffi.wasm_table_get(tbl, 0)
|
|
ffi.wasm_table_delete(tbl)
|
|
|
|
def test_wasm_table_get_null_table(self):
|
|
ffi.wasm_table_get(ffi.create_null_pointer(ffi.wasm_table_t), 0)
|
|
|
|
def test_wasm_table_get_out_of_bounds(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
ffi.wasm_table_get(tbl, 1_000_000_000)
|
|
|
|
def test_wasm_ref(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
self.assertIsNotNullPointer(func)
|
|
|
|
ref = ffi.wasm_func_as_ref(func)
|
|
self.assertIsNotNullPointer(ref)
|
|
|
|
func_from_ref = ffi.wasm_ref_as_func(ref)
|
|
self.assertEqual(
|
|
ffi.dereference(ffi.wasm_func_type(func)),
|
|
ffi.dereference(ffi.wasm_func_type(func_from_ref)),
|
|
)
|
|
|
|
def test_wasm_table_set(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
self.assertIsNotNullPointer(tbl)
|
|
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
ref = ffi.wasm_func_as_ref(func)
|
|
|
|
ffi.wasm_table_set(tbl, 0, ref)
|
|
|
|
ref_ret = ffi.wasm_table_get(tbl, 0)
|
|
self.assertIsNotNullPointer(ref_ret)
|
|
func_ret = ffi.wasm_ref_as_func(ref_ret)
|
|
self.assertEqual(
|
|
ffi.dereference(ffi.wasm_func_type(func)),
|
|
ffi.dereference(ffi.wasm_func_type(func_ret)),
|
|
)
|
|
|
|
def test_wasm_table_set_unlinked(self):
|
|
vt = ffi.wasm_valtype_new(ffi.WASM_FUNCREF)
|
|
limits = ffi.wasm_limits_new(10, 15)
|
|
tt = ffi.wasm_tabletype_new(vt, limits)
|
|
tbl = ffi.wasm_table_new(
|
|
self._wasm_store, tt, ffi.create_null_pointer(ffi.wasm_ref_t)
|
|
)
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
ref = ffi.wasm_func_as_ref(func)
|
|
ffi.wasm_table_set(tbl, 0, ref)
|
|
ffi.wasm_table_delete(tbl)
|
|
|
|
def test_wasm_table_set_null_table(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
ref = ffi.wasm_func_as_ref(func)
|
|
ffi.wasm_table_set(ffi.create_null_pointer(ffi.wasm_table_t), 0, ref)
|
|
|
|
def test_wasm_table_set_null_ref(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
ffi.wasm_table_set(tbl, 0, ffi.create_null_pointer(ffi.wasm_ref_t))
|
|
|
|
def test_wasm_table_set_out_of_bounds(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
tbl = ffi.wasm_extern_as_table(export_list[3])
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
ref = ffi.wasm_func_as_ref(func)
|
|
ffi.wasm_table_set(tbl, 1_000_000_000, ref)
|
|
|
|
def test_wasm_memory_size(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
mem = ffi.wasm_extern_as_memory(export_list[2])
|
|
self.assertIsNotNullPointer(mem)
|
|
|
|
pg_sz = ffi.wasm_memory_size(mem)
|
|
self.assertEqual(pg_sz, 1)
|
|
|
|
def test_wasm_memory_size_unlinked(self):
|
|
limits = ffi.wasm_limits_new(10, 12)
|
|
mt = ffi.wasm_memorytype_new(limits)
|
|
mem = ffi.wasm_memory_new(self._wasm_store, mt)
|
|
ffi.wasm_memory_size(mem)
|
|
ffi.wasm_memory_delete(mem)
|
|
|
|
def test_wasm_memory_data(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
mem = ffi.wasm_extern_as_memory(export_list[2])
|
|
self.assertIsNotNullPointer(mem)
|
|
|
|
data_base = ffi.wasm_memory_data(mem)
|
|
self.assertIsNotNone(data_base)
|
|
|
|
def test_wasm_memory_data_unlinked(self):
|
|
limits = ffi.wasm_limits_new(10, 12)
|
|
mt = ffi.wasm_memorytype_new(limits)
|
|
mem = ffi.wasm_memory_new(self._wasm_store, mt)
|
|
ffi.wasm_memory_data(mem)
|
|
ffi.wasm_memory_delete(mem)
|
|
|
|
def test_wasm_memory_data_size(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
mem = ffi.wasm_extern_as_memory(export_list[2])
|
|
self.assertIsNotNullPointer(mem)
|
|
|
|
mem_sz = ffi.wasm_memory_data_size(mem)
|
|
self.assertGreater(mem_sz, 0)
|
|
|
|
def test_wasm_memory_data_size_unlinked(self):
|
|
limits = ffi.wasm_limits_new(10, 12)
|
|
mt = ffi.wasm_memorytype_new(limits)
|
|
mem = ffi.wasm_memory_new(self._wasm_store, mt)
|
|
ffi.wasm_memory_data_size(mem)
|
|
ffi.wasm_memory_delete(mem)
|
|
|
|
def test_wasm_trap(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[0])
|
|
# make a call
|
|
params = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(params)
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(results)
|
|
|
|
trap = ffi.wasm_func_call(func, params, results)
|
|
self.assertIsNotNullPointer(trap)
|
|
|
|
message = ffi.wasm_message_t()
|
|
ffi.wasm_trap_message(trap, message)
|
|
self.assertIsNotNullPointer(c.pointer(message))
|
|
|
|
# not a function internal exception
|
|
frame = ffi.wasm_trap_origin(trap)
|
|
self.assertIsNullPointer(frame)
|
|
|
|
@unittest.skipUnless(
|
|
TEST_WITH_WAMR_BUILD_DUMP_CALL_STACK,
|
|
"need to enable WAMR_BUILD_DUMP_CALL_STACK",
|
|
)
|
|
# assertions only works if enabling WAMR_BUILD_DUMP_CALL_STACK
|
|
def test_wasm_frame(self):
|
|
export_list = ffi.wasm_vec_to_list(self.exports)
|
|
func = ffi.wasm_extern_as_func(export_list[4])
|
|
# make a call
|
|
params = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(params)
|
|
results = ffi.wasm_val_vec_t()
|
|
ffi.wasm_val_vec_new_empty(results)
|
|
|
|
print("Making a call...")
|
|
trap = ffi.wasm_func_call(func, params, results)
|
|
|
|
message = ffi.wasm_message_t()
|
|
ffi.wasm_trap_message(trap, message)
|
|
self.assertIsNotNullPointer(c.pointer(message))
|
|
print(message)
|
|
|
|
frame = ffi.wasm_trap_origin(trap)
|
|
self.assertIsNotNullPointer(frame)
|
|
print(ffi.dereference(frame))
|
|
|
|
traces = ffi.wasm_frame_vec_t()
|
|
ffi.wasm_trap_trace(trap, traces)
|
|
self.assertIsNotNullPointer(c.pointer(frame))
|
|
|
|
instance = ffi.wasm_frame_instance(frame)
|
|
self.assertIsNotNullPointer(instance)
|
|
|
|
module_offset = ffi.wasm_frame_module_offset(frame)
|
|
|
|
func_index = ffi.wasm_frame_func_index(frame)
|
|
self.assertEqual(func_index, 2)
|
|
|
|
func_offset = ffi.wasm_frame_func_offset(frame)
|
|
self.assertGreater(func_offset, 0)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
print("Shutting down...")
|
|
ffi.wasm_store_delete(cls._wasm_store)
|
|
ffi.wasm_engine_delete(cls._wasm_engine)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|