# -*- 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.wasmcapi.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_EXTERNREF, 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_module_delete(module) self.assertIsNullPointer(instance) 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_module_delete(module) self.assertIsNullPointer(instance) # 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()