Coverage for tests/test_shared_memory.py: 100%

1import unittest 

2 

3from wasmtime import * 

4 

5def engine_with_shared_memory() -> Engine: 

6 config = Config() 

7 config.shared_memory = True 

8 return Engine(config) 

9 

10class TestSharedMemory(unittest.TestCase): 

11 def test_new(self): 

12 engine = engine_with_shared_memory() 

13 memory_type = MemoryType(Limits(1, 2), is_64=False, shared=True) 

14 assert(not memory_type.is_64) 

15 shared_memory = SharedMemory(engine, memory_type) 

16 with self.assertRaises(TypeError): 

17 shared_memory.grow('') # type: ignore 

18 with self.assertRaises(WasmtimeError): 

19 shared_memory.grow(-1) 

20 self.assertEqual(shared_memory.data_ptr()[0], 0) 

21 self.assertEqual(shared_memory.data_len(), 65536) 

22 self.assertTrue(isinstance(shared_memory.type(), MemoryType)) 

23 

24 def test_grow(self): 

25 engine = engine_with_shared_memory() 

26 memory_type = MemoryType(Limits(1, 2), shared=True) 

27 shared_memory = SharedMemory(engine, memory_type) 

28 assert(shared_memory.grow(1) == 1) 

29 assert(shared_memory.grow(0) == 2) 

30 with self.assertRaises(WasmtimeError): 

31 shared_memory.grow(1) 

32 

33 def test_errors(self): 

34 engine = engine_with_shared_memory() 

35 ty = MemoryType(Limits(1, 2), shared=True) 

36 with self.assertRaises(AttributeError): 

37 SharedMemory(1, ty) # type: ignore 

38 with self.assertRaises(AttributeError): 

39 SharedMemory(engine, 1) # type: ignore 

40 

41 def test_shared_memory_type_fails_if_no_max_specified(self): 

42 with self.assertRaises(WasmtimeError): 

43 # Shared memories must have a max size 

44 MemoryType(Limits(0x100000000, None), shared=True) 

45 

46 def test_shared_memory_type_works_if_min_max_i64_is_set(self): 

47 ty = MemoryType(Limits(0x100000000, 0x100000000), is_64=True, shared=True) 

48 assert(ty.limits.min == 0x100000000) 

49 assert(ty.limits.max == 0x100000000) 

50 assert(ty.is_64) 

51 

52 def test_shared_memory_type_fails_if_is_too_large(self): 

53 with self.assertRaises(WasmtimeError): 

54 MemoryType(Limits(1, 0x100000000), shared=True) 

55 

56 def test_memory_type_has_to_be_shared(self): 

57 engine = engine_with_shared_memory() 

58 ty = MemoryType(Limits(1, 2)) 

59 with self.assertRaises(WasmtimeError): 

60 SharedMemory(engine, ty)