3d34a91f0b
Implement the first version of Python language binding Co-authored-by: liang.he <liang.he@intel.com>
1589 lines
51 KiB
Python
1589 lines
51 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 unittest
|
|
from venv import create
|
|
|
|
from wamr.ffi import *
|
|
|
|
# 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 1 2)
|
|
# (table 1 funcref)
|
|
# )
|
|
MODULE_BINARY = (
|
|
b"\x00asm\x01\x00\x00\x00\x01\x0b\x02`\x01}\x01|`\x02\x7f~\x00"
|
|
b"\x02\x14\x02\x03mod\x02g0\x03\x7f\x00\x03mod\x02f0\x00\x00\x03"
|
|
b"\x02\x01\x01\x04\x04\x01p\x00\x01\x05\x04\x01\x01\x01\x02\x06\t"
|
|
b"\x01}\x01C\xc3\xf5H@\x0b\x07\x0b\x02\x02f1\x00\x01\x02g1\x03\x01\n"
|
|
b"\x04\x01\x02\x00\x0b"
|
|
)
|
|
|
|
|
|
@wasm_func_cb_decl
|
|
def callback(args, results):
|
|
# pylint: disable=unused-argument
|
|
print("summer")
|
|
|
|
|
|
@wasm_func_with_env_cb_decl
|
|
def callback_with_env(env, args, results):
|
|
# pylint: disable=unused-argument
|
|
print("summer")
|
|
|
|
|
|
class BasicTestSuite(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls._wasm_engine = wasm_engine_new()
|
|
cls._wasm_store = wasm_store_new(cls._wasm_engine)
|
|
|
|
def assertIsNullPointer(self, c_pointer):
|
|
if not is_null_pointer(c_pointer):
|
|
self.fail("not a null pointer")
|
|
|
|
def assertIsNotNullPointer(self, c_pointer):
|
|
if is_null_pointer(c_pointer):
|
|
self.fail("not a non-null pointer")
|
|
|
|
def test_wasm_valkind(self):
|
|
self.assertEqual(
|
|
[WASM_I32, WASM_I64, WASM_F32, WASM_F64, WASM_ANYREF, WASM_FUNCREF],
|
|
[0, 1, 2, 3, 128, 129],
|
|
)
|
|
|
|
def test_wasm_valtype_new_pos(self):
|
|
vt = wasm_valtype_new(WASM_I32)
|
|
self.assertIsNotNullPointer(vt)
|
|
wasm_valtype_delete(vt)
|
|
|
|
def test_wasm_valtype_new_neg(self):
|
|
vt = wasm_valtype_new(37)
|
|
self.assertIsNullPointer(vt)
|
|
wasm_valtype_delete(vt)
|
|
|
|
def test_wasm_valtype_kind_pos(self):
|
|
vt = wasm_valtype_new(WASM_I64)
|
|
self.assertEqual(wasm_valtype_kind(vt), WASM_I64)
|
|
wasm_valtype_delete(vt)
|
|
|
|
def test_wasm_valtype_kind_neg(self):
|
|
wasm_valtype_kind(create_null_pointer(wasm_valtype_t))
|
|
|
|
def test_wasm_valtype_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
wasm_valtype_delete(vt)
|
|
|
|
def test_wasm_valtype_delete_neg(self):
|
|
wasm_valtype_delete(create_null_pointer(wasm_valtype_t))
|
|
|
|
def test_wasm_valtype_copy_pos(self):
|
|
vt1 = wasm_valtype_new(WASM_FUNCREF)
|
|
vt2 = wasm_valtype_copy(vt1)
|
|
|
|
self.assertIsNotNone(vt1)
|
|
self.assertIsNotNullPointer(vt1)
|
|
self.assertEqual(dereference(vt1), dereference(vt2))
|
|
|
|
wasm_valtype_delete(vt1)
|
|
wasm_valtype_delete(vt2)
|
|
|
|
def test_wasm_valtype_copy_neg(self):
|
|
vt = wasm_valtype_copy(create_null_pointer(wasm_valtype_t))
|
|
self.assertIsNotNone(vt)
|
|
self.assertIsNullPointer(vt)
|
|
|
|
def test_list_to_carray(self):
|
|
v1 = wasm_valtype_new(WASM_I64)
|
|
v2 = wasm_valtype_new(WASM_F32)
|
|
v3 = wasm_valtype_new(WASM_FUNCREF)
|
|
data = list_to_carray(c.POINTER(wasm_valtype_t), v1, v2, v3)
|
|
|
|
self.assertIsNotNone(data)
|
|
self.assertTrue(isinstance(data, c.Array))
|
|
self.assertEqual(data._length_, 3)
|
|
self.assertEqual(dereference(data[0]), dereference(v1))
|
|
self.assertEqual(dereference(data[1]), dereference(v2))
|
|
self.assertEqual(dereference(data[2]), dereference(v3))
|
|
|
|
wasm_valtype_delete(v1)
|
|
wasm_valtype_delete(v2)
|
|
wasm_valtype_delete(v3)
|
|
|
|
def test_wasm_valtype_vec_new_pos(self):
|
|
def_vt_list = [
|
|
wasm_valtype_new(WASM_I32),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_FUNCREF),
|
|
]
|
|
data = list_to_carray(c.POINTER(wasm_valtype_t), *def_vt_list)
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new(vt_vec, 3, data)
|
|
|
|
self.assertEqual(vt_vec.size, 3)
|
|
self.assertEqual(vt_vec.num_elems, 3)
|
|
self.assertIsNotNullPointer(vt_vec.data)
|
|
|
|
ret_vt_list = wasm_vec_to_list(vt_vec)
|
|
ret_vt_list = [dereference(vt) for vt in ret_vt_list]
|
|
def_vt_list = [dereference(vt) for vt in def_vt_list]
|
|
self.assertEqual(ret_vt_list, def_vt_list)
|
|
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_new_neg(self):
|
|
data = list_to_carray(
|
|
c.POINTER(wasm_valtype_t),
|
|
wasm_valtype_new(WASM_I32),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_FUNCREF),
|
|
)
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new(vt_vec, 1_000_000_000, data)
|
|
|
|
self.assertEqual(vt_vec.size, 0)
|
|
self.assertIsNullPointer(vt_vec.data)
|
|
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_new_null_out(self):
|
|
data = list_to_carray(
|
|
c.POINTER(wasm_valtype_t),
|
|
wasm_valtype_new(WASM_I32),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_FUNCREF),
|
|
)
|
|
wasm_valtype_vec_new(create_null_pointer(wasm_valtype_vec_t), 10, data)
|
|
|
|
def test_wasm_valtype_vec_new_null_data(self):
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new(vt_vec, 3, create_null_pointer(wasm_valtype_t))
|
|
self.assertIsNotNone(vt_vec)
|
|
self.assertIsNotNullPointer(c.pointer(vt_vec))
|
|
|
|
def test_wasm_valtype_vec_new_uninitialized_pos(self):
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_uninitialized((vt_vec), 2)
|
|
self.assertEqual(2, vt_vec.size)
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_new_uninitialized_neg(self):
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_uninitialized(vt_vec, 1_000_000_000)
|
|
self.assertEqual(vt_vec.size, 0)
|
|
self.assertIsNullPointer(vt_vec.data)
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_new_uninitialized_null_out(self):
|
|
wasm_valtype_vec_new_uninitialized(create_null_pointer(wasm_valtype_vec_t), 2)
|
|
|
|
def test_wasm_valtype_vec_new_empty_pos(self):
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_empty(vt_vec)
|
|
self.assertEqual(0, vt_vec.size)
|
|
self.assertIsNullPointer(vt_vec.data)
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_new_empty_neg(self):
|
|
wasm_valtype_vec_new_empty(create_null_pointer(wasm_valtype_vec_t))
|
|
|
|
def test_wasm_valtype_vec_copy_pos(self):
|
|
vt_vec1 = wasm_valtype_vec_t()
|
|
vt1 = wasm_valtype_new(WASM_F32)
|
|
vt2 = wasm_valtype_new(WASM_I32)
|
|
data = list_to_carray(c.POINTER(wasm_valtype_t), vt1, vt2)
|
|
wasm_valtype_vec_new(vt_vec1, 2, data)
|
|
|
|
vt_vec2 = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_copy(vt_vec2, vt_vec1)
|
|
|
|
print(f"{vt_vec1} --> {vt_vec2}")
|
|
|
|
self.assertEqual(vt_vec2.size, 2)
|
|
self.assertEqual(vt_vec2.num_elems, 2)
|
|
self.assertEqual(dereference(vt_vec2.data[0]), dereference(vt1))
|
|
self.assertEqual(dereference(vt_vec2.data[1]), dereference(vt2))
|
|
|
|
wasm_valtype_vec_delete(vt_vec1)
|
|
wasm_valtype_vec_delete(vt_vec2)
|
|
|
|
def test_wasm_valtype_vec_copy_null_src(self):
|
|
dst = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_copy(dst, create_null_pointer(wasm_valtype_vec_t))
|
|
self.assertIsNotNullPointer(c.pointer(dst))
|
|
self.assertIsNullPointer(dst.data)
|
|
|
|
def test_wasm_valtype_vec_copy_null_dst(self):
|
|
src = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_empty(src)
|
|
wasm_valtype_vec_copy(create_null_pointer(wasm_valtype_vec_t), src)
|
|
wasm_valtype_vec_delete(src)
|
|
|
|
def test_wasm_valtype_vec_delete_pos(self):
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_uninitialized(vt_vec, 10)
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
vt_vec = wasm_valtype_vec_t()
|
|
wasm_valtype_vec_new_empty(vt_vec)
|
|
wasm_valtype_vec_delete(vt_vec)
|
|
|
|
def test_wasm_valtype_vec_delete_neg(self):
|
|
wasm_valtype_vec_delete(create_null_pointer(wasm_valtype_vec_t))
|
|
|
|
def test_wasm_functype_new_0_0(self):
|
|
ft = wasm_functype_new_0_0()
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
self.assertEqual(0, dereference(wasm_functype_params(ft)).size)
|
|
self.assertEqual(0, dereference(wasm_functype_results(ft)).size)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_1_0(self):
|
|
vt = wasm_valtype_new(WASM_I64)
|
|
ft = wasm_functype_new_1_0(vt)
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
params = wasm_vec_to_list(wasm_functype_params(ft))
|
|
self.assertEqual([dereference(p) for p in params], [dereference(vt)])
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_2_0(self):
|
|
vt1 = wasm_valtype_new(WASM_I64)
|
|
vt2 = wasm_valtype_new(WASM_F64)
|
|
ft = wasm_functype_new_2_0(vt1, vt2)
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
self.assertEqual(2, dereference(wasm_functype_params(ft)).size)
|
|
self.assertEqual(0, dereference(wasm_functype_results(ft)).size)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_3_0(self):
|
|
vt_list = [
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_I64),
|
|
]
|
|
ft = wasm_functype_new_3_0(*vt_list)
|
|
|
|
params = wasm_vec_to_list(wasm_functype_params(ft))
|
|
self.assertEqual(
|
|
[dereference(p) for p in params],
|
|
[dereference(vt) for vt in vt_list],
|
|
)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_0_1(self):
|
|
vt1 = wasm_valtype_new(WASM_I64)
|
|
ft = wasm_functype_new_0_1(vt1)
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
self.assertEqual(0, dereference(wasm_functype_params(ft)).size)
|
|
self.assertEqual(1, dereference(wasm_functype_results(ft)).size)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_1_1(self):
|
|
vt1 = wasm_valtype_new(WASM_I64)
|
|
vt2 = wasm_valtype_new(WASM_F64)
|
|
ft = wasm_functype_new_1_1(vt1, vt2)
|
|
|
|
params = wasm_vec_to_list(wasm_functype_params(ft))
|
|
self.assertEqual(dereference(params[0]), dereference(vt1))
|
|
|
|
results = wasm_vec_to_list(wasm_functype_results(ft))
|
|
self.assertEqual(dereference(results[0]), dereference(vt2))
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_2_1(self):
|
|
vt_list = [
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_I64),
|
|
]
|
|
ft = wasm_functype_new_2_1(*vt_list)
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
self.assertEqual(2, dereference(wasm_functype_params(ft)).size)
|
|
self.assertEqual(1, dereference(wasm_functype_results(ft)).size)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_3_1(self):
|
|
vt_list = [
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_I32),
|
|
]
|
|
ft = wasm_functype_new_3_1(*vt_list)
|
|
|
|
params = wasm_vec_to_list(wasm_functype_params(ft))
|
|
self.assertEqual(
|
|
[dereference(p) for p in params], [dereference(vt) for vt in vt_list[:3]]
|
|
)
|
|
|
|
results = wasm_vec_to_list(wasm_functype_results(ft))
|
|
self.assertEqual(dereference(results[0]), dereference(vt_list[-1]))
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_new_neg(self):
|
|
ft = wasm_functype_new(
|
|
create_null_pointer(wasm_valtype_vec_t),
|
|
create_null_pointer(wasm_valtype_vec_t),
|
|
)
|
|
|
|
self.assertIsNotNullPointer(ft)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_delete_pos(self):
|
|
ft = wasm_functype_new_0_0()
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_delete_neg(self):
|
|
wasm_functype_delete(create_null_pointer(wasm_functype_t))
|
|
|
|
def test_wasm_functype_params_pos(self):
|
|
vt_list = [
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_I64),
|
|
]
|
|
ft = wasm_functype_new_3_0(*vt_list)
|
|
params = wasm_vec_to_list(wasm_functype_params(ft))
|
|
|
|
self.assertEqual(
|
|
[dereference(p) for p in params],
|
|
[dereference(vt) for vt in vt_list],
|
|
)
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_params_neg(self):
|
|
params = wasm_functype_params(create_null_pointer(wasm_functype_t))
|
|
self.assertIsNullPointer(params)
|
|
|
|
def test_wasm_functype_results_pos(self):
|
|
vt1 = wasm_valtype_new(WASM_I64)
|
|
ft = wasm_functype_new_0_1(vt1)
|
|
results = wasm_vec_to_list(wasm_functype_results(ft))
|
|
|
|
self.assertEqual(dereference(results[0]), dereference(vt1))
|
|
|
|
wasm_functype_delete(ft)
|
|
|
|
def test_wasm_functype_results_neg(self):
|
|
results = wasm_functype_results(create_null_pointer(wasm_functype_t))
|
|
self.assertIsNullPointer(results)
|
|
|
|
def test_wasm_functype_copy_pos(self):
|
|
ft1 = wasm_functype_new_2_1(
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_F64),
|
|
wasm_valtype_new(WASM_I64),
|
|
)
|
|
ft2 = wasm_functype_copy(ft1)
|
|
|
|
self.assertIsNotNullPointer(ft2)
|
|
self.assertEqual(2, dereference(wasm_functype_params(ft1)).size)
|
|
self.assertEqual(1, dereference(wasm_functype_results(ft2)).size)
|
|
|
|
wasm_functype_delete(ft1)
|
|
wasm_functype_delete(ft2)
|
|
|
|
def test_wasm_functype_copy_neg(self):
|
|
ft2 = wasm_functype_copy(create_null_pointer(wasm_functype_t))
|
|
self.assertIsNullPointer(ft2)
|
|
wasm_functype_delete(ft2)
|
|
|
|
def test_wasm_globaltype_new_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
gt = wasm_globaltype_new(vt, True)
|
|
|
|
self.assertIsNotNullPointer(gt)
|
|
|
|
wasm_globaltype_delete(gt)
|
|
|
|
def test_wasm_globaltype_new_neg(self):
|
|
gt = wasm_globaltype_new(create_null_pointer(wasm_valtype_t), True)
|
|
self.assertIsNullPointer(gt)
|
|
wasm_globaltype_delete(gt)
|
|
|
|
def test_wasm_globaltype_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
wasm_globaltype_delete(gt)
|
|
|
|
def test_wasm_globaltype_delete_neg(self):
|
|
wasm_globaltype_delete(create_null_pointer(wasm_globaltype_t))
|
|
|
|
def test_wasm_globaltype_content_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
gt = wasm_globaltype_new(vt, True)
|
|
gt_ret = wasm_globaltype_content(gt)
|
|
|
|
self.assertEqual(dereference(vt), dereference(gt_ret))
|
|
|
|
wasm_globaltype_delete(gt)
|
|
|
|
def test_wasm_globaltype_content_neg(self):
|
|
gt_ret = wasm_globaltype_content(create_null_pointer(wasm_globaltype_t))
|
|
self.assertIsNullPointer(gt_ret)
|
|
|
|
def test_wasm_globaltype_mutability_pos(self):
|
|
vt1 = wasm_valtype_new(WASM_F32)
|
|
gt1 = wasm_globaltype_new(vt1, False)
|
|
vt2 = wasm_valtype_new(WASM_F32)
|
|
gt2 = wasm_globaltype_new(vt2, True)
|
|
|
|
self.assertFalse(wasm_globaltype_mutability(gt1))
|
|
self.assertTrue(wasm_globaltype_mutability(gt2))
|
|
|
|
wasm_globaltype_delete(gt1)
|
|
wasm_globaltype_delete(gt2)
|
|
|
|
def test_wasm_globaltype_mutability_neg(self):
|
|
self.assertFalse(
|
|
wasm_globaltype_mutability(create_null_pointer(wasm_globaltype_t))
|
|
)
|
|
|
|
def test_wasm_globaltype_copy_pos(self):
|
|
vt = wasm_valtype_new(WASM_I32)
|
|
gt1 = wasm_globaltype_new(vt, True)
|
|
gt2 = wasm_globaltype_copy(gt1)
|
|
|
|
self.assertEqual(dereference(gt1), dereference(gt2))
|
|
|
|
wasm_globaltype_delete(gt1)
|
|
wasm_globaltype_delete(gt2)
|
|
|
|
def test_wasm_globaltype_copy_neg(self):
|
|
gt2 = wasm_globaltype_copy(create_null_pointer(wasm_globaltype_t))
|
|
|
|
self.assertIsNullPointer(gt2)
|
|
wasm_globaltype_delete(gt2)
|
|
|
|
def test_wasm_limit_new(self):
|
|
limit = wasm_limits_new(10, 20)
|
|
self.assertIsNotNullPointer(limit)
|
|
self.assertEqual(dereference(limit).min, 10)
|
|
self.assertEqual(dereference(limit).max, 20)
|
|
|
|
def test_wasm_tabletype_new_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limit = wasm_limits_new(0, 0xFF)
|
|
tt = wasm_tabletype_new(vt, limit)
|
|
|
|
self.assertIsNotNullPointer(tt)
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_new_null_val_type(self):
|
|
limit = wasm_limits_new(0, 0xFFFFFFFF)
|
|
tt = wasm_tabletype_new(create_null_pointer(wasm_valtype_t), limit)
|
|
|
|
self.assertIsNullPointer(tt)
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_new_null_limits(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
tt = wasm_tabletype_new(vt, create_null_pointer(wasm_limits_t))
|
|
|
|
self.assertIsNullPointer(tt)
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limit = wasm_limits_new(0, 0xFFFFFFFF)
|
|
tt = wasm_tabletype_new(vt, limit)
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_delete_neg(self):
|
|
wasm_tabletype_delete(create_null_pointer(wasm_tabletype_t))
|
|
|
|
def test_wasm_tabletype_element_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limit = wasm_limits_new(0, 0xFFFFFFFF)
|
|
tt = wasm_tabletype_new(vt, limit)
|
|
vt_ret = wasm_tabletype_element(tt)
|
|
|
|
self.assertEqual(dereference(vt), dereference(vt_ret))
|
|
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_element_neg(self):
|
|
vt_ret = wasm_tabletype_element(create_null_pointer(wasm_tabletype_t))
|
|
self.assertIsNullPointer(vt_ret)
|
|
|
|
def test_wasm_tabletype_limits_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limit = wasm_limits_new(100, 256)
|
|
tt = wasm_tabletype_new(vt, limit)
|
|
limit_ret = wasm_tabletype_limits(tt)
|
|
|
|
self.assertEqual(dereference(limit), dereference(limit_ret))
|
|
|
|
wasm_tabletype_delete(tt)
|
|
|
|
def test_wasm_tabletype_limits_neg(self):
|
|
limit_ret = wasm_tabletype_limits(create_null_pointer(wasm_tabletype_t))
|
|
self.assertIsNullPointer(limit_ret)
|
|
|
|
def test_wasm_tabletype_copy_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limit = wasm_limits_new(13, 19)
|
|
tt1 = wasm_tabletype_new(vt, limit)
|
|
tt2 = wasm_tabletype_copy(tt1)
|
|
|
|
self.assertEqual(dereference(tt1), dereference(tt2))
|
|
|
|
wasm_tabletype_delete(tt1)
|
|
wasm_tabletype_delete(tt2)
|
|
|
|
def test_wasm_tabletype_copy_neg(self):
|
|
tt2 = wasm_tabletype_copy(create_null_pointer(wasm_tabletype_t))
|
|
self.assertIsNullPointer(tt2)
|
|
wasm_tabletype_delete(tt2)
|
|
|
|
def test_wasm_memorytype_new_pos(self):
|
|
limit = wasm_limits_new(0, 3)
|
|
mt = wasm_memorytype_new(limit)
|
|
|
|
self.assertIsNotNullPointer(mt)
|
|
|
|
wasm_memorytype_delete(mt)
|
|
|
|
def test_wasm_memorytype_new_neg(self):
|
|
mt = wasm_memorytype_new(None)
|
|
|
|
self.assertIsNullPointer(mt)
|
|
|
|
wasm_memorytype_delete(mt)
|
|
|
|
def test_wasm_memorytype_delete_pos(self):
|
|
limit = wasm_limits_new(1, 2)
|
|
mt = wasm_memorytype_new(limit)
|
|
wasm_memorytype_delete(mt)
|
|
|
|
def test_wasm_memorytype_delete_neg(self):
|
|
wasm_memorytype_delete(create_null_pointer(wasm_memorytype_t))
|
|
|
|
def test_wasm_memorytype_limits_pos(self):
|
|
limit = wasm_limits_new(3, 8)
|
|
mt = wasm_memorytype_new(limit)
|
|
limit_ret = wasm_memorytype_limits(mt)
|
|
|
|
self.assertEqual(dereference(limit), dereference(limit_ret))
|
|
|
|
wasm_memorytype_delete(mt)
|
|
|
|
def test_wasm_memorytype_limits_neg(self):
|
|
wasm_memorytype_limits(create_null_pointer(wasm_memorytype_t))
|
|
|
|
def test_wasm_memorytype_copy_pos(self):
|
|
limit = wasm_limits_new(7, 13)
|
|
mt1 = wasm_memorytype_new(limit)
|
|
mt2 = wasm_memorytype_copy(mt1)
|
|
|
|
self.assertEqual(
|
|
dereference(mt1),
|
|
dereference(mt2),
|
|
)
|
|
|
|
wasm_memorytype_delete(mt1)
|
|
wasm_memorytype_delete(mt2)
|
|
|
|
def test_wasm_memorytype_copy_neg(self):
|
|
mt2 = wasm_memorytype_copy(create_null_pointer(wasm_memorytype_t))
|
|
|
|
self.assertIsNullPointer(mt2)
|
|
|
|
wasm_memorytype_delete(mt2)
|
|
|
|
def test_wasm_externtype_kind_pos(self):
|
|
ft = wasm_functype_new_0_0()
|
|
gt = wasm_globaltype_new(wasm_valtype_new(WASM_FUNCREF), True)
|
|
mt = wasm_memorytype_new(wasm_limits_new(1, 2))
|
|
tt = wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), wasm_limits_new(10, 20))
|
|
ets = [
|
|
wasm_functype_as_externtype(ft),
|
|
wasm_globaltype_as_externtype(gt),
|
|
wasm_memorytype_as_externtype(mt),
|
|
wasm_tabletype_as_externtype(tt),
|
|
]
|
|
type_kinds = [wasm_externtype_kind(et) for et in ets]
|
|
|
|
self.assertEqual(
|
|
type_kinds,
|
|
[
|
|
WASM_EXTERN_FUNC,
|
|
WASM_EXTERN_GLOBAL,
|
|
WASM_EXTERN_MEMORY,
|
|
WASM_EXTERN_TABLE,
|
|
],
|
|
)
|
|
|
|
[wasm_externtype_delete(et) for et in ets]
|
|
|
|
def test_wasm_externtype_kind_neg(self):
|
|
et = wasm_memorytype_as_externtype(create_null_pointer(wasm_memorytype_t))
|
|
self.assertIsNullPointer(et)
|
|
|
|
def test_wasm_externtype_delete_pos(self):
|
|
mt = wasm_memorytype_new(wasm_limits_new(10, 20))
|
|
et = wasm_memorytype_as_externtype(mt)
|
|
wasm_externtype_delete(et)
|
|
|
|
def test_wasm_externtype_delete_neg(self):
|
|
et = wasm_globaltype_as_externtype(create_null_pointer(wasm_globaltype_t))
|
|
wasm_externtype_delete(et)
|
|
|
|
def test_wasm_externtype_copy_pos(self):
|
|
tt1 = wasm_tabletype_new(
|
|
wasm_valtype_new(WASM_FUNCREF), wasm_limits_new(10, 20)
|
|
)
|
|
et1 = wasm_tabletype_as_externtype(tt1)
|
|
et2 = wasm_externtype_copy(et1)
|
|
|
|
tt2 = wasm_externtype_as_tabletype(et2)
|
|
self.assertEqual(dereference(tt1), dereference(tt2))
|
|
|
|
wasm_externtype_delete(et2)
|
|
wasm_externtype_delete(et1)
|
|
|
|
def test_wasm_externtype_copy_neg(self):
|
|
et1 = create_null_pointer(wasm_externtype_t)
|
|
et2 = wasm_externtype_copy(et1)
|
|
wasm_externtype_delete(et2)
|
|
wasm_externtype_delete(et1)
|
|
|
|
def test_wasm_name_new_from_string(self):
|
|
s = "let the stars shine upon you"
|
|
name = wasm_name_new_from_string(s)
|
|
|
|
name_data = c.cast(name.data, c.c_char_p)
|
|
name_data = bytes.decode(name_data.value)
|
|
self.assertEqual(name_data, s)
|
|
|
|
def test_wasm_importtype_new_pos(self):
|
|
module_name = "mA"
|
|
field_name = "func#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(module_name, field_name, et)
|
|
|
|
self.assertIsNotNullPointer(it)
|
|
self.assertEqual(dereference(wasm_importtype_module(it)), module_name)
|
|
self.assertEqual(dereference(wasm_importtype_name(it)), field_name)
|
|
self.assertEqual(dereference(wasm_importtype_type(it)), dereference(et))
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_new_null_ext_type(self):
|
|
module_name = "mA"
|
|
field_name = "func#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
it = wasm_importtype_new(
|
|
module_name,
|
|
field_name,
|
|
create_null_pointer(wasm_externtype_t),
|
|
)
|
|
|
|
self.assertIsNullPointer(it)
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_new_null_module(self):
|
|
field_name = "func#1"
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(create_null_pointer(wasm_name_t), field_name, et)
|
|
|
|
self.assertIsNullPointer(it)
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_new_null_field(self):
|
|
module_name = "mA"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(module_name, create_null_pointer(wasm_name_t), et)
|
|
|
|
self.assertIsNullPointer(it)
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_copy_pos(self):
|
|
module_name = "mA"
|
|
field_name = "memory#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
mt = wasm_memorytype_new(wasm_limits_new(10, 20))
|
|
et = wasm_memorytype_as_externtype(mt)
|
|
it1 = wasm_importtype_new(module_name, field_name, et)
|
|
it2 = wasm_importtype_copy(it1)
|
|
|
|
self.assertEqual(dereference(it1), dereference(it2))
|
|
|
|
wasm_importtype_delete(it1)
|
|
wasm_importtype_delete(it2)
|
|
|
|
def test_wasm_importtype_copy_neg(self):
|
|
it1 = create_null_pointer(wasm_importtype_t)
|
|
it2 = wasm_importtype_copy(it1)
|
|
wasm_importtype_delete(it1)
|
|
wasm_importtype_delete(it2)
|
|
|
|
def test_wasm_importtype_delete_pos(self):
|
|
module_name = "mA"
|
|
field_name = "memory#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
tt = wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), wasm_limits_new(10, 20))
|
|
et = wasm_tabletype_as_externtype(tt)
|
|
it = wasm_importtype_new(module_name, field_name, et)
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_delete_neg(self):
|
|
wasm_importtype_delete(create_null_pointer(wasm_importtype_t))
|
|
|
|
def test_wasm_importtype_module_pos(self):
|
|
module_name = "mA"
|
|
field_name = "func#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(module_name, field_name, et)
|
|
module_name_ret = wasm_importtype_module(it)
|
|
|
|
self.assertEqual(dereference(module_name_ret), module_name)
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_module_neg(self):
|
|
it = create_null_pointer(wasm_importtype_t)
|
|
wasm_importtype_module(it)
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_name_pos(self):
|
|
module_name = "mA"
|
|
field_name = "func#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(module_name, field_name, et)
|
|
field_name_ret = wasm_importtype_name(it)
|
|
|
|
self.assertEqual(dereference(field_name_ret), field_name)
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_name_neg(self):
|
|
it = create_null_pointer(wasm_importtype_t)
|
|
wasm_importtype_name(it)
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_type_pos(self):
|
|
module_name = "mA"
|
|
field_name = "func#1"
|
|
module_name = wasm_name_new_from_string(module_name)
|
|
field_name = wasm_name_new_from_string(field_name)
|
|
ft = wasm_functype_new_0_0()
|
|
et = wasm_functype_as_externtype(ft)
|
|
it = wasm_importtype_new(module_name, field_name, et)
|
|
et_ret = wasm_importtype_type(it)
|
|
|
|
self.assertEqual(dereference(et_ret), dereference(et))
|
|
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_importtype_type_neg(self):
|
|
it = create_null_pointer(wasm_importtype_t)
|
|
wasm_importtype_type(it)
|
|
wasm_importtype_delete(it)
|
|
|
|
def test_wasm_exporttype_new_pos(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
ft = wasm_functype_new_0_0()
|
|
ft = wasm_functype_as_externtype(ft)
|
|
et = wasm_exporttype_new(name, ft)
|
|
|
|
self.assertIsNotNullPointer(et)
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_new_null_name(self):
|
|
name = create_null_pointer(wasm_name_t)
|
|
ft = wasm_functype_new_0_0()
|
|
ft = wasm_functype_as_externtype(ft)
|
|
et = wasm_exporttype_new(name, ft)
|
|
|
|
self.assertIsNullPointer(et)
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_new_null_ext_type(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
ext_type = create_null_pointer(wasm_externtype_t)
|
|
et = wasm_exporttype_new(name, ext_type)
|
|
|
|
self.assertIsNullPointer(et)
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_copy_pos(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
gt = wasm_globaltype_new(wasm_valtype_new(WASM_F32), True)
|
|
gt = wasm_globaltype_as_externtype(gt)
|
|
et1 = wasm_exporttype_new(name, gt)
|
|
et2 = wasm_exporttype_copy(et1)
|
|
|
|
self.assertEqual(
|
|
dereference(et1),
|
|
dereference(et2),
|
|
)
|
|
|
|
wasm_exporttype_delete(et1)
|
|
wasm_exporttype_delete(et2)
|
|
|
|
def test_wasm_exporttype_copy_neg(self):
|
|
et1 = create_null_pointer(wasm_exporttype_t)
|
|
et2 = wasm_exporttype_copy(et1)
|
|
|
|
wasm_exporttype_delete(et1)
|
|
wasm_exporttype_delete(et2)
|
|
|
|
def test_wasm_exporttype_delete_pos(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
mt = wasm_memorytype_new(wasm_limits_new(10, 20))
|
|
mt = wasm_memorytype_as_externtype(mt)
|
|
et = wasm_exporttype_new(name, mt)
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_delete_neg(self):
|
|
et = create_null_pointer(wasm_exporttype_t)
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_name_pos(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
tt = wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), wasm_limits_new(10, 20))
|
|
tt = wasm_tabletype_as_externtype(tt)
|
|
et = wasm_exporttype_new(name, tt)
|
|
name_ret = wasm_exporttype_name(et)
|
|
|
|
self.assertEqual(dereference(name_ret), name)
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_name_neg(self):
|
|
et = create_null_pointer(wasm_exporttype_t)
|
|
wasm_exporttype_name(et)
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_type_pos(self):
|
|
name = "hello"
|
|
name = wasm_name_new_from_string(name)
|
|
tt = wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), wasm_limits_new(10, 20))
|
|
tt = wasm_tabletype_as_externtype(tt)
|
|
et = wasm_exporttype_new(name, tt)
|
|
tt_ret = wasm_exporttype_type(et)
|
|
|
|
self.assertEqual(dereference(tt_ret), dereference(tt))
|
|
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_exporttype_type_neg(self):
|
|
et = create_null_pointer(wasm_exporttype_t)
|
|
wasm_exporttype_type(et)
|
|
wasm_exporttype_delete(et)
|
|
|
|
def test_wasm_i32_val(self):
|
|
val = wasm_i32_val(100)
|
|
|
|
self.assertEqual(val.kind, WASM_I32)
|
|
self.assertEqual(val.of.i32, 100)
|
|
|
|
# can not use wasm_val_delete() because it is not malloced
|
|
|
|
def test_wasm_i64_val(self):
|
|
val = wasm_i64_val(-100)
|
|
|
|
self.assertEqual(val.kind, WASM_I64)
|
|
self.assertEqual(val.of.i64, -100)
|
|
|
|
# can not use wasm_val_delete() because it is not malloced
|
|
|
|
def test_wasm_f32_val(self):
|
|
val = wasm_f32_val(100)
|
|
|
|
self.assertEqual(val.kind, WASM_F32)
|
|
self.assertEqual(val.of.f32, 100.0)
|
|
|
|
# can not use wasm_val_delete() because it is not malloced
|
|
|
|
def test_wasm_f64_val(self):
|
|
val = wasm_f64_val(-100)
|
|
|
|
self.assertEqual(val.kind, WASM_F64)
|
|
self.assertEqual(val.of.f64, -100.0)
|
|
|
|
# can not use wasm_val_delete() because it is not malloced
|
|
|
|
# there is no wasm_val_new() to malloc a wasm_val_t
|
|
def test_wasm_val_delete(self):
|
|
pass
|
|
|
|
def test_wasm_val_copy(self):
|
|
v1 = wasm_f32_val(3.14)
|
|
v2 = wasm_val_t()
|
|
wasm_val_copy(v1, v2)
|
|
|
|
self.assertEqual(v1, v2)
|
|
# can not use wasm_val_delete() because it is not malloced
|
|
|
|
def test_wasm_ref_delete_neg(self):
|
|
ref = create_null_pointer(wasm_ref_t)
|
|
wasm_ref_delete(ref)
|
|
|
|
ref = wasm_ref_t()
|
|
wasm_ref_delete(ref)
|
|
|
|
def test_wasm_trap_new_pos(self):
|
|
# can't create a trap with traces(wasm_frame_vec_t)
|
|
msg = wasm_name_new_from_string("a fake trap")
|
|
trap = wasm_trap_new(self._wasm_store, msg)
|
|
|
|
self.assertIsNotNone(trap)
|
|
|
|
wasm_trap_delete(trap)
|
|
|
|
def test_wasm_trap_new_null_msg(self):
|
|
trap = wasm_trap_new(self._wasm_store, create_null_pointer(wasm_name_t))
|
|
|
|
self.assertIsNotNone(trap)
|
|
self.assertIsNotNullPointer(trap)
|
|
|
|
wasm_trap_delete(trap)
|
|
|
|
def test_wasm_trap_message_pos(self):
|
|
msg = wasm_name_new_from_string("a fake trap")
|
|
trap = wasm_trap_new(self._wasm_store, msg)
|
|
msg_in_trap = wasm_message_t()
|
|
wasm_trap_message(trap, msg_in_trap)
|
|
|
|
self.assertEqual(
|
|
msg,
|
|
msg_in_trap,
|
|
)
|
|
|
|
wasm_trap_delete(trap)
|
|
|
|
def test_wasm_trap_message_null_trap(self):
|
|
msg = wasm_name_new_from_string("a fake trap")
|
|
wasm_trap_message(create_null_pointer(wasm_trap_t), msg)
|
|
|
|
def test_wasm_trap_message_null_out(self):
|
|
msg = wasm_name_new_from_string("a fake trap")
|
|
trap = wasm_trap_new(self._wasm_store, msg)
|
|
wasm_trap_message(trap, create_null_pointer(wasm_message_t))
|
|
wasm_trap_delete(trap)
|
|
|
|
# test those APIs in advance:
|
|
# wasm_trap_origin
|
|
# wasm_trap_trace
|
|
# wasm_frame_delete
|
|
# wasm_frame_copy
|
|
# wasm_frame_module_offset
|
|
# wasm_frame_instance
|
|
# wasm_frame_func_index
|
|
# wasm_frame_func_offset
|
|
|
|
def test_wasm_foreign_new_pos(self):
|
|
foreign = wasm_foreign_new(self._wasm_store)
|
|
|
|
self.assertIsNotNone(foreign)
|
|
self.assertIsNotNullPointer(foreign)
|
|
|
|
wasm_foreign_delete(foreign)
|
|
|
|
def test_wasm_foreign_new_neg(self):
|
|
foreign = wasm_foreign_new(create_null_pointer(wasm_store_t))
|
|
|
|
self.assertIsNotNone(foreign)
|
|
self.assertIsNullPointer(foreign)
|
|
|
|
wasm_foreign_delete(foreign)
|
|
|
|
def test_wasm_foreign_delete_pos(self):
|
|
foreign = wasm_foreign_new(self._wasm_store)
|
|
wasm_foreign_delete(foreign)
|
|
|
|
def test_wasm_foreign_delete_neg(self):
|
|
wasm_foreign_delete(create_null_pointer(wasm_foreign_t))
|
|
|
|
# wasm_egnine_new()/wasm_engine_delete()
|
|
# wasm_store_new()/wasm_store_delete()
|
|
# used in setUpClass() and tearDownClass
|
|
|
|
def test_wasm_module_new_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
|
|
self.assertIsNotNone(module)
|
|
self.assertIsNotNullPointer(module)
|
|
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_new_neg(self):
|
|
module = wasm_module_new(self._wasm_store, create_null_pointer(wasm_byte_vec_t))
|
|
|
|
self.assertIsNotNone(module)
|
|
self.assertIsNullPointer(module)
|
|
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_delete_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_delete_neg(self):
|
|
module = wasm_module_new(self._wasm_store, create_null_pointer(wasm_byte_vec_t))
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_validate_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
validation = wasm_module_validate(self._wasm_store, binary)
|
|
|
|
self.assertTrue(validation)
|
|
|
|
wasm_byte_vec_delete(binary)
|
|
|
|
def test_wasm_module_validate_neg(self):
|
|
tmp = (1024).to_bytes(2, byteorder="big")
|
|
binary = load_module_file(tmp)
|
|
validation = wasm_module_validate(self._wasm_store, binary)
|
|
|
|
self.assertFalse(validation)
|
|
|
|
wasm_byte_vec_delete(binary)
|
|
|
|
def test_wasm_module_imports_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
imports = wasm_importtype_vec_t()
|
|
wasm_module_imports(module, imports)
|
|
|
|
imports_list = wasm_vec_to_list(imports)
|
|
self.assertEqual(len(imports_list), 2)
|
|
|
|
func_type = wasm_functype_new_1_1(
|
|
wasm_valtype_new(WASM_F32),
|
|
wasm_valtype_new(WASM_F64),
|
|
)
|
|
ext_type = wasm_functype_as_externtype(func_type)
|
|
self.assertEqual(
|
|
dereference(wasm_importtype_type(imports_list[0])), dereference(ext_type)
|
|
)
|
|
|
|
wasm_externtype_delete(ext_type)
|
|
wasm_importtype_vec_delete(imports)
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_imports_null_module(self):
|
|
imports = wasm_importtype_vec_t()
|
|
wasm_module_imports(create_null_pointer(wasm_module_t), imports)
|
|
|
|
self.assertEqual(imports.size, 0)
|
|
|
|
wasm_importtype_vec_delete(imports)
|
|
|
|
def test_wasm_module_imports_null_out(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
wasm_module_imports(module, create_null_pointer(wasm_importtype_vec_t))
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_exports_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
exports = wasm_exporttype_vec_t()
|
|
wasm_module_exports(module, exports)
|
|
|
|
exports_list = wasm_vec_to_list(exports)
|
|
self.assertEqual(len(exports_list), 2)
|
|
|
|
glbl_type = wasm_globaltype_new(wasm_valtype_new(WASM_F32), True)
|
|
ext_type = wasm_globaltype_as_externtype(glbl_type)
|
|
self.assertEqual(
|
|
dereference(wasm_exporttype_type(exports_list[1])), dereference(ext_type)
|
|
)
|
|
|
|
wasm_exporttype_vec_delete(exports)
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_module_exports_null_module(self):
|
|
exports = wasm_exporttype_vec_t()
|
|
wasm_module_exports(create_null_pointer(wasm_module_t), exports)
|
|
|
|
self.assertEqual(exports.size, 0)
|
|
|
|
wasm_exporttype_vec_delete(exports)
|
|
|
|
def test_wasm_module_exports_null_out(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
wasm_module_exports(module, create_null_pointer(wasm_exporttype_vec_t))
|
|
wasm_byte_vec_delete(binary)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_instance_new_pos_empty_imports(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
imports = wasm_extern_vec_t()
|
|
wasm_extern_vec_new_empty(imports)
|
|
instance = wasm_instance_new(
|
|
self._wasm_store, module, imports, create_null_pointer(wasm_trap_t)
|
|
)
|
|
|
|
wasm_instance_delete(instance)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_instance_new_pos(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
|
|
ft = wasm_functype_new_1_1(
|
|
wasm_valtype_new(WASM_F32),
|
|
wasm_valtype_new(WASM_F64),
|
|
)
|
|
func = wasm_func_new(self._wasm_store, ft, callback)
|
|
|
|
gt = wasm_globaltype_new(wasm_valtype_new(WASM_I32), True)
|
|
init = wasm_i32_val(100)
|
|
gb = wasm_global_new(self._wasm_store, gt, init)
|
|
|
|
imports = wasm_extern_vec_t()
|
|
data = list_to_carray(
|
|
c.POINTER(wasm_extern_t),
|
|
wasm_func_as_extern(func),
|
|
wasm_global_as_extern(gb),
|
|
)
|
|
wasm_extern_vec_new(imports, 2, data)
|
|
|
|
instance = wasm_instance_new(
|
|
self._wasm_store, module, imports, create_null_pointer(wasm_trap_t)
|
|
)
|
|
|
|
self.assertIsNotNone(instance)
|
|
|
|
wasm_instance_delete(instance)
|
|
wasm_module_delete(module)
|
|
|
|
def test_wasm_instance_new_neg_null_imports(self):
|
|
binary = load_module_file(MODULE_BINARY)
|
|
module = wasm_module_new(self._wasm_store, binary)
|
|
instance = wasm_instance_new(
|
|
self._wasm_store,
|
|
module,
|
|
create_null_pointer(wasm_extern_vec_t),
|
|
create_null_pointer(wasm_trap_t),
|
|
)
|
|
|
|
wasm_instance_delete(instance)
|
|
wasm_module_delete(module)
|
|
|
|
# test those APIs in advanced:
|
|
# wasm_instance_delete
|
|
# wasm_instance_exports
|
|
|
|
def test_wasm_func_new_pos(self):
|
|
vt1 = wasm_valtype_new(WASM_F32)
|
|
vt2 = wasm_valtype_new(WASM_FUNCREF)
|
|
ft = wasm_functype_new_1_1(vt1, vt2)
|
|
func = wasm_func_new(self._wasm_store, ft, callback)
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNotNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_new_null_type(self):
|
|
func = wasm_func_new(
|
|
self._wasm_store, create_null_pointer(wasm_functype_t), callback
|
|
)
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_new_null_callback(self):
|
|
vt1 = wasm_valtype_new(WASM_F32)
|
|
vt2 = wasm_valtype_new(WASM_FUNCREF)
|
|
ft = wasm_functype_new_1_1(vt1, vt2)
|
|
func = wasm_func_new(self._wasm_store, ft, wasm_func_callback_t())
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_new_with_env_pos(self):
|
|
ft = wasm_functype_new_3_1(
|
|
wasm_valtype_new(WASM_I32),
|
|
wasm_valtype_new(WASM_F32),
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_I64),
|
|
)
|
|
func = wasm_func_new_with_env(
|
|
self._wasm_store,
|
|
ft,
|
|
callback_with_env,
|
|
c.c_void_p(0),
|
|
wasm_finalizer(0),
|
|
)
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNotNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_new_with_env_null_type(self):
|
|
func = wasm_func_new_with_env(
|
|
self._wasm_store,
|
|
create_null_pointer(wasm_functype_t),
|
|
callback_with_env,
|
|
c.c_void_p(0),
|
|
wasm_finalizer(0),
|
|
)
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_new_with_env_null_callback(self):
|
|
ft = wasm_functype_new_3_1(
|
|
wasm_valtype_new(WASM_I32),
|
|
wasm_valtype_new(WASM_F32),
|
|
wasm_valtype_new(WASM_I64),
|
|
wasm_valtype_new(WASM_I64),
|
|
)
|
|
func = wasm_func_new_with_env(
|
|
self._wasm_store,
|
|
ft,
|
|
wasm_func_callback_with_env_t(),
|
|
c.c_void_p(0),
|
|
wasm_finalizer(0),
|
|
)
|
|
|
|
self.assertIsNotNone(func)
|
|
self.assertIsNullPointer(func)
|
|
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_delete_pos(self):
|
|
ft = wasm_functype_new_0_0()
|
|
func = wasm_func_new(self._wasm_store, ft, callback)
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_delete_neg(self):
|
|
wasm_func_delete(create_null_pointer(wasm_func_t))
|
|
|
|
def test_wasm_func_type_pos(self):
|
|
ft = wasm_functype_new_2_0(
|
|
wasm_valtype_new(WASM_F32),
|
|
wasm_valtype_new(WASM_FUNCREF),
|
|
)
|
|
func = wasm_func_new(self._wasm_store, ft, callback)
|
|
ft_ret = wasm_func_type(func)
|
|
|
|
self.assertEqual(
|
|
dereference(ft),
|
|
dereference(ft_ret),
|
|
)
|
|
|
|
wasm_functype_delete(ft_ret)
|
|
wasm_func_delete(func)
|
|
|
|
def test_wasm_func_type_neg(self):
|
|
ft_ret = wasm_func_type(create_null_pointer(wasm_func_t))
|
|
wasm_functype_delete(ft_ret)
|
|
|
|
def test_wasm_func_copy_pos(self):
|
|
vt1 = wasm_valtype_new(WASM_F32)
|
|
ft = wasm_functype_new_0_1(vt1)
|
|
func1 = wasm_func_new(self._wasm_store, ft, callback)
|
|
func2 = wasm_func_copy(func1)
|
|
|
|
self.assertEqual(
|
|
dereference(wasm_func_type(func1)), dereference(wasm_func_type(func2))
|
|
)
|
|
|
|
wasm_func_delete(func2)
|
|
wasm_func_delete(func1)
|
|
|
|
def test_wasm_func_copy_neg(self):
|
|
func1 = wasm_func_new(
|
|
self._wasm_store, create_null_pointer(wasm_functype_t), callback
|
|
)
|
|
func2 = wasm_func_copy(func1)
|
|
|
|
wasm_func_delete(func2)
|
|
wasm_func_delete(func1)
|
|
|
|
# test wasm_func_call in advanced
|
|
|
|
def test_wasm_global_new_pos(self):
|
|
vt = wasm_valtype_new(WASM_F32)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
v = wasm_f32_val(3.14)
|
|
g = wasm_global_new(self._wasm_store, gt, v)
|
|
|
|
self.assertIsNotNone(g)
|
|
self.assertIsNotNullPointer(g)
|
|
|
|
wasm_globaltype_delete(gt)
|
|
wasm_global_delete(g)
|
|
|
|
def test_wasm_global_new_null_type(self):
|
|
v = wasm_f32_val(3.14)
|
|
g = wasm_global_new(self._wasm_store, create_null_pointer(wasm_globaltype_t), v)
|
|
|
|
self.assertIsNotNone(g)
|
|
self.assertIsNullPointer(g)
|
|
|
|
wasm_global_delete(g)
|
|
|
|
def test_wasm_global_new_null_init(self):
|
|
vt = wasm_valtype_new(WASM_F32)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
g = wasm_global_new(self._wasm_store, gt, create_null_pointer(wasm_val_t))
|
|
|
|
self.assertIsNotNone(g)
|
|
self.assertIsNullPointer(g)
|
|
|
|
wasm_globaltype_delete(gt)
|
|
wasm_global_delete(g)
|
|
|
|
def test_wasm_global_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_I32)
|
|
gt = wasm_globaltype_new(vt, True)
|
|
v = wasm_i32_val(3)
|
|
g = wasm_global_new(self._wasm_store, gt, v)
|
|
wasm_globaltype_delete(gt)
|
|
wasm_global_delete(g)
|
|
|
|
def test_wasm_global_delete_neg(self):
|
|
wasm_global_delete(create_null_pointer(wasm_global_t))
|
|
|
|
def test_wasm_global_type_pos(self):
|
|
vt = wasm_valtype_new(WASM_I64)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
v = wasm_i32_val(3)
|
|
g = wasm_global_new(self._wasm_store, gt, v)
|
|
gt_ret = wasm_global_type(g)
|
|
|
|
self.assertEqual(dereference(gt), dereference(gt_ret))
|
|
|
|
wasm_globaltype_delete(gt)
|
|
wasm_globaltype_delete(gt_ret)
|
|
wasm_global_delete(g)
|
|
|
|
def test_wasm_global_type_neg(self):
|
|
gt = wasm_global_type(create_null_pointer(wasm_global_t))
|
|
wasm_globaltype_delete(gt)
|
|
|
|
# test wasm_global_get and wasm_global_set in advanced
|
|
|
|
def test_wasm_table_new_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limits = wasm_limits_new(10, 15)
|
|
tt = wasm_tabletype_new(vt, limits)
|
|
t = wasm_table_new(self._wasm_store, tt, create_null_pointer(wasm_ref_t))
|
|
|
|
self.assertIsNotNone(t)
|
|
self.assertIsNotNullPointer(t)
|
|
|
|
wasm_table_delete(t)
|
|
|
|
def test_wasm_table_new_null_type(self):
|
|
t = wasm_table_new(
|
|
self._wasm_store,
|
|
create_null_pointer(wasm_tabletype_t),
|
|
create_null_pointer(wasm_ref_t),
|
|
)
|
|
|
|
self.assertIsNotNone(t)
|
|
self.assertIsNullPointer(t)
|
|
|
|
wasm_table_delete(t)
|
|
|
|
def test_wasm_table_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limits = wasm_limits_new(10, 15)
|
|
tt = wasm_tabletype_new(vt, limits)
|
|
t = wasm_table_new(self._wasm_store, tt, create_null_pointer(wasm_ref_t))
|
|
wasm_table_delete(t)
|
|
|
|
def test_wasm_table_delete_neg(self):
|
|
wasm_table_delete(create_null_pointer(wasm_table_t))
|
|
|
|
def test_wasm_table_type_pos(self):
|
|
vt = wasm_valtype_new(WASM_FUNCREF)
|
|
limits = wasm_limits_new(1, 2)
|
|
tt = wasm_tabletype_new(vt, limits)
|
|
t = wasm_table_new(self._wasm_store, tt, create_null_pointer(wasm_ref_t))
|
|
tt_ret = wasm_table_type(t)
|
|
|
|
self.assertEqual(
|
|
dereference(tt),
|
|
dereference(tt_ret),
|
|
)
|
|
|
|
wasm_table_delete(t)
|
|
|
|
def test_wasm_table_type_neg(self):
|
|
t = wasm_table_new(
|
|
self._wasm_store,
|
|
create_null_pointer(wasm_tabletype_t),
|
|
create_null_pointer(wasm_ref_t),
|
|
)
|
|
tt_ret = wasm_table_type(t)
|
|
wasm_table_delete(t)
|
|
|
|
# test wasm_table_size, wasm_table_get, wasm_table_set in advanced
|
|
|
|
def test_wasm_memory_new_pos(self):
|
|
limits = wasm_limits_new(10, 12)
|
|
mt = wasm_memorytype_new(limits)
|
|
m = wasm_memory_new(self._wasm_store, mt)
|
|
|
|
self.assertIsNotNullPointer(m)
|
|
|
|
wasm_memory_delete(m)
|
|
|
|
def test_wasm_memory_new_null_type(self):
|
|
m = wasm_memory_new(self._wasm_store, create_null_pointer(wasm_memorytype_t))
|
|
|
|
self.assertIsNullPointer(m)
|
|
|
|
wasm_memory_delete(m)
|
|
|
|
def test_wasm_memory_delete_pos(self):
|
|
limits = wasm_limits_new(10, 21)
|
|
mt = wasm_memorytype_new(limits)
|
|
m = wasm_memory_new(self._wasm_store, mt)
|
|
wasm_memory_delete(m)
|
|
|
|
def test_wasm_memory_delete_neg(self):
|
|
wasm_memory_delete(create_null_pointer(wasm_memory_t))
|
|
|
|
def test_wasm_memory_type_pos(self):
|
|
limits = wasm_limits_new(10, 21)
|
|
mt = wasm_memorytype_new(limits)
|
|
m = wasm_memory_new(self._wasm_store, mt)
|
|
mt_ret = wasm_memory_type(m)
|
|
|
|
self.assertEqual(dereference(mt), dereference(mt_ret))
|
|
|
|
wasm_memory_delete(m)
|
|
|
|
def test_wasm_memory_type_neg(self):
|
|
mt = wasm_memory_type(create_null_pointer(wasm_memory_t))
|
|
|
|
self.assertIsNullPointer(mt)
|
|
wasm_memorytype_delete(mt)
|
|
|
|
# test wasm_memory_size, wasm_memory_data, wasm_memory_data_size in advanced
|
|
|
|
def test_wasm_extern_delete_pos(self):
|
|
vt = wasm_valtype_new(WASM_I64)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
v = wasm_i64_val(128)
|
|
glb = wasm_global_new(self._wasm_store, gt, v)
|
|
etrn = wasm_global_as_extern(glb)
|
|
wasm_extern_delete(etrn)
|
|
|
|
def test_wasm_extern_delete_neg(self):
|
|
etrn = wasm_global_as_extern(create_null_pointer(wasm_global_t))
|
|
wasm_extern_delete(etrn)
|
|
|
|
def test_wasm_extern_type_pos(self):
|
|
vt = wasm_valtype_new(WASM_I64)
|
|
gt = wasm_globaltype_new(vt, False)
|
|
v = wasm_i64_val(128)
|
|
glb = wasm_global_new(self._wasm_store, gt, v)
|
|
etrn = wasm_global_as_extern(glb)
|
|
|
|
tp = wasm_extern_type(etrn)
|
|
gt_ret = wasm_externtype_as_globaltype(tp)
|
|
self.assertEqual(
|
|
dereference(gt),
|
|
dereference(gt_ret),
|
|
)
|
|
wasm_extern_delete(etrn)
|
|
|
|
def test_wasm_extern_type_neg(self):
|
|
wasm_extern_type(create_null_pointer(wasm_extern_t))
|
|
|
|
def test_wasm_extern_kind_pos(self):
|
|
ft = wasm_functype_new_0_0()
|
|
func = wasm_func_new(self._wasm_store, ft, callback)
|
|
etrn = wasm_func_as_extern(func)
|
|
kind = wasm_extern_kind(etrn)
|
|
|
|
self.assertEqual(WASM_EXTERN_FUNC, kind)
|
|
|
|
wasm_extern_delete(etrn)
|
|
|
|
def test_wasm_extern_kind_neg(self):
|
|
wasm_extern_kind(create_null_pointer(wasm_extern_t))
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
wasm_store_delete(cls._wasm_store)
|
|
wasm_engine_delete(cls._wasm_engine)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|