Coverage for tests/test_memory.py: 100%

1import unittest 

2 

3from wasmtime import * 

4 

5 

6class TestMemory(unittest.TestCase): 

7 def test_new(self): 

8 store = Store() 

9 ty = MemoryType(Limits(1, None)) 

10 assert(not ty.is_64) 

11 memory = Memory(store, ty) 

12 self.assertEqual(memory.type(store).limits, Limits(1, None)) 

13 self.assertEqual(memory.size(store), 1) 

14 self.assertTrue(memory.grow(store, 1)) 

15 self.assertEqual(memory.size(store), 2) 

16 self.assertTrue(memory.grow(store, 0)) 

17 self.assertEqual(memory.size(store), 2) 

18 with self.assertRaises(TypeError): 

19 memory.grow(store, '') # type: ignore 

20 with self.assertRaises(WasmtimeError): 

21 memory.grow(store, -1) 

22 self.assertEqual(memory.data_ptr(store)[0], 0) 

23 self.assertEqual(memory.data_len(store), 65536 * 2) 

24 self.assertTrue(isinstance(memory.type(store), MemoryType)) 

25 

26 def test_grow(self): 

27 store = Store() 

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

29 memory = Memory(store, ty) 

30 assert(memory.grow(store, 1) == 1) 

31 assert(memory.grow(store, 0) == 2) 

32 with self.assertRaises(WasmtimeError): 

33 memory.grow(store, 1) 

34 

35 def test_errors(self): 

36 store = Store() 

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

38 with self.assertRaises(AttributeError): 

39 Memory(1, ty) # type: ignore 

40 with self.assertRaises(AttributeError): 

41 Memory(store, 1) # type: ignore 

42 

43 def test_large(self): 

44 ty = MemoryType(Limits(0x100000000, None), is_64=True) 

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

46 assert(ty.limits.max is None) 

47 assert(ty.is_64) 

48 ty = MemoryType(Limits(0x100000000, 0x100000000), is_64=True) 

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

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

51 

52 with self.assertRaises(WasmtimeError): 

53 MemoryType(Limits(0x100000000, None)) 

54 with self.assertRaises(WasmtimeError): 

55 MemoryType(Limits(1, 0x100000000)) 

56 

57 def test_slices(self): 

58 store = Store() 

59 ty = MemoryType(Limits(1, None)) 

60 memory = Memory(store, ty) 

61 memory.grow(store, 2) 

62 data_ptr = memory.data_ptr(store) 

63 ba = bytearray([i for i in range(200)]) 

64 size_bytes = memory.data_len(store) 

65 # happy cases 

66 offset = 2048 

67 ba_size = len(ba) 

68 # write with start and ommit stop 

69 memory.write(store, ba, offset) 

70 # check write success byte by byte, whole is asserted with read 

71 self.assertEqual(data_ptr[offset], 0) 

72 self.assertEqual(data_ptr[offset + 1], 1) 

73 self.assertEqual(data_ptr[offset + 199], 199) 

74 # read while and assert whole area 

75 out = memory.read(store, offset, offset + ba_size) 

76 self.assertEqual(ba, out) 

77 self.assertEqual(len(memory.read(store, -10)), 10) 

78 # write with start and stop 

79 memory.write(store, ba, offset + ba_size) 

80 out = memory.read(store, offset + ba_size, offset + ba_size + ba_size) 

81 self.assertEqual(ba, out) 

82 # assert old 

83 self.assertEqual(data_ptr[offset], 0) 

84 self.assertEqual(data_ptr[offset + 1], 1) 

85 self.assertEqual(data_ptr[offset + 199], 199) 

86 # assert new 

87 self.assertEqual(data_ptr[offset + ba_size], 0) 

88 self.assertEqual(data_ptr[offset + ba_size + 1], 1) 

89 self.assertEqual(data_ptr[offset + ba_size + 199], 199) 

90 # edge cases 

91 # empty slices 

92 self.assertEqual(len(memory.read(store, 0, 0)), 0) 

93 self.assertEqual(len(memory.read(store, offset, offset)), 0) 

94 self.assertEqual(len(memory.read(store, offset, offset - 1)), 0) 

95 # out of bound access returns empty array similar to list slice 

96 self.assertEqual(len(memory.read(store, size_bytes + 1)), 0) 

97 # write empty 

98 self.assertEqual(memory.write(store, bytearray(0), offset), 0) 

99 self.assertEqual(memory.write(store, bytearray(b""), offset), 0) 

100 with self.assertRaises(IndexError): 

101 memory.write(store, ba, size_bytes) 

102 with self.assertRaises(IndexError): 

103 memory.write(store, ba, size_bytes - ba_size + 1) 

104 self.assertEqual(memory.write(store, ba, -ba_size), ba_size) 

105 out = memory.read(store, -ba_size) 

106 self.assertEqual(ba, out)