Coverage for /home/jenkins/workspace/NDS/Zserio/NDS_ZSERIO-linux-build/compiler/extensions/python/runtime/tests/test_bitwriter.py: 100%

204 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-12-13 15:12 +0000

1import unittest 

2 

3from zserio.bitbuffer import BitBuffer 

4from zserio.bitwriter import BitStreamWriter 

5from zserio.exception import PythonRuntimeException 

6from zserio.limits import (VARINT16_MIN, VARINT16_MAX, VARINT32_MIN, VARINT32_MAX, VARINT64_MIN, VARINT64_MAX, 

7 VARINT_MIN, VARINT_MAX, VARUINT16_MIN, VARUINT16_MAX, VARUINT32_MIN, VARUINT32_MAX, 

8 VARUINT64_MIN, VARUINT64_MAX, VARUINT_MIN, VARUINT_MAX, VARSIZE_MIN, VARSIZE_MAX) 

9 

10class BitStreamWriterTest(unittest.TestCase): 

11 

12 def test_write_unaligned_data(self): 

13 # number expected to be written at offset 

14 test_value = 123 

15 

16 for offset in range(65): 

17 writer = BitStreamWriter() 

18 

19 if offset != 0: 

20 writer.write_bits(0, offset) 

21 writer.write_bits(test_value, 8) 

22 

23 # check written value 

24 buffer = writer.byte_array 

25 written_test_value = buffer[offset // 8] << (offset % 8) 

26 if offset % 8 != 0: 

27 written_test_value |= buffer[offset // 8 + 1] >> (8 - (offset % 8)) 

28 self.assertEqual(test_value, written_test_value, msg="Offset: " + str(offset)) 

29 

30 def test_write_bits(self): 

31 writer = BitStreamWriter() 

32 writer.write_bits(0, 8) 

33 writer.write_bits(255, 8) 

34 writer.write_bits(1, 1) 

35 writer.write_bits(0x3f, 6) 

36 writer.write_bits(1, 1) 

37 self.assertEqual(b'\x00\xff\xff', writer.byte_array) 

38 self.assertEqual(3 * 8, writer.bitposition) 

39 writer.write_bits(0xff, 8) 

40 self.assertEqual(b'\x00\xff\xff\xff', writer.byte_array) 

41 self.assertEqual(4 * 8, writer.bitposition) 

42 writer.write_bits(0, 4) 

43 self.assertEqual(b'\x00\xff\xff\xff\x00', writer.byte_array) 

44 self.assertEqual(4 * 8 + 4, writer.bitposition) 

45 writer.write_bits(0x0f, 4) 

46 self.assertEqual(b'\x00\xff\xff\xff\x0f', writer.byte_array) 

47 self.assertEqual(5 * 8, writer.bitposition) 

48 writer.write_bits(0x80, 8) 

49 self.assertEqual(b'\x00\xff\xff\xff\x0f\x80', writer.byte_array) 

50 self.assertEqual(6 * 8, writer.bitposition) 

51 

52 with self.assertRaises(PythonRuntimeException): 

53 writer.write_bits(1, 0) # zero bits! 

54 

55 with self.assertRaises(PythonRuntimeException): 

56 writer.write_bits(1, -1) # negative number of bits! 

57 

58 with self.assertRaises(PythonRuntimeException): 

59 writer.write_bits(256, 8) # above the upper bound 

60 

61 with self.assertRaises(PythonRuntimeException): 

62 writer.write_bits(-1, 8) # below the lower bound 

63 

64 def test_write_signed_bits(self): 

65 writer = BitStreamWriter() 

66 writer.write_signed_bits(0, 1) 

67 writer.write_signed_bits(-1, 2) 

68 writer.write_signed_bits(-1, 5) 

69 self.assertEqual(b'\x7f', writer.byte_array) 

70 self.assertEqual(8, writer.bitposition) 

71 writer.write_signed_bits(-1, 1) 

72 writer.write_signed_bits(-1, 7) 

73 self.assertEqual(b'\x7f\xff', writer.byte_array) 

74 self.assertEqual(16, writer.bitposition) 

75 

76 with self.assertRaises(PythonRuntimeException): 

77 writer.write_signed_bits(1, 0) # zero bits! 

78 

79 with self.assertRaises(PythonRuntimeException): 

80 writer.write_signed_bits(1, 1) # above the upper bound 

81 

82 with self.assertRaises(PythonRuntimeException): 

83 writer.write_signed_bits(128, 8) # above the upper bound 

84 

85 with self.assertRaises(PythonRuntimeException): 

86 writer.write_signed_bits(-129, 8) # below the lower bound 

87 

88 def test_write_varint16(self): 

89 writer = BitStreamWriter() 

90 writer.write_varint16(0) 

91 self.assertEqual(8, writer.bitposition) 

92 self.assertEqual(b'\x00', writer.byte_array) 

93 with self.assertRaises(PythonRuntimeException): 

94 writer.write_varint16(VARINT16_MIN - 1) 

95 with self.assertRaises(PythonRuntimeException): 

96 writer.write_varint16(VARINT16_MAX + 1) 

97 

98 def test_write_varint32(self): 

99 writer = BitStreamWriter() 

100 writer.write_varint32(0) 

101 self.assertEqual(8, writer.bitposition) 

102 self.assertEqual(b'\x00', writer.byte_array) 

103 with self.assertRaises(PythonRuntimeException): 

104 writer.write_varint32(VARINT32_MIN - 1) 

105 with self.assertRaises(PythonRuntimeException): 

106 writer.write_varint32(VARINT32_MAX + 1) 

107 

108 def test_write_varint64(self): 

109 writer = BitStreamWriter() 

110 writer.write_varint64(0) 

111 self.assertEqual(8, writer.bitposition) 

112 self.assertEqual(b'\x00', writer.byte_array) 

113 with self.assertRaises(PythonRuntimeException): 

114 writer.write_varint64(VARINT64_MIN - 1) 

115 with self.assertRaises(PythonRuntimeException): 

116 writer.write_varint64(VARINT64_MAX + 1) 

117 

118 def test_write_varint(self): 

119 writer = BitStreamWriter() 

120 writer.write_varint(0) 

121 self.assertEqual(b'\x00', writer.byte_array) 

122 self.assertEqual(8, writer.bitposition) 

123 writer.write_varint(VARINT_MIN) 

124 self.assertEqual(16, writer.bitposition) 

125 self.assertEqual(b'\x00\x80', writer.byte_array) # INT64_MIN is encoded as -0 

126 with self.assertRaises(PythonRuntimeException): 

127 writer.write_varint(VARINT_MIN - 1) 

128 with self.assertRaises(PythonRuntimeException): 

129 writer.write_varint(VARINT_MAX + 1) 

130 

131 def test_write_varuint16(self): 

132 writer = BitStreamWriter() 

133 writer.write_varuint16(0) 

134 self.assertEqual(8, writer.bitposition) 

135 self.assertEqual(b'\x00', writer.byte_array) 

136 with self.assertRaises(PythonRuntimeException): 

137 writer.write_varuint16(VARUINT16_MIN - 1) 

138 with self.assertRaises(PythonRuntimeException): 

139 writer.write_varuint16(VARUINT16_MAX + 1) 

140 

141 def test_write_varuint32(self): 

142 writer = BitStreamWriter() 

143 writer.write_varuint32(0) 

144 self.assertEqual(8, writer.bitposition) 

145 self.assertEqual(b'\x00', writer.byte_array) 

146 with self.assertRaises(PythonRuntimeException): 

147 writer.write_varuint32(VARUINT32_MIN - 1) 

148 with self.assertRaises(PythonRuntimeException): 

149 writer.write_varuint32(VARUINT32_MAX + 1) 

150 

151 def test_write_varuint64(self): 

152 writer = BitStreamWriter() 

153 writer.write_varuint64(0) 

154 self.assertEqual(8, writer.bitposition) 

155 self.assertEqual(b'\x00', writer.byte_array) 

156 with self.assertRaises(PythonRuntimeException): 

157 writer.write_varuint64(VARUINT64_MIN - 1) 

158 with self.assertRaises(PythonRuntimeException): 

159 writer.write_varuint64(VARUINT64_MAX + 1) 

160 

161 def test_write_varuint(self): 

162 writer = BitStreamWriter() 

163 writer.write_varuint(0) 

164 self.assertEqual(8, writer.bitposition) 

165 self.assertEqual(b'\x00', writer.byte_array) 

166 with self.assertRaises(PythonRuntimeException): 

167 writer.write_varuint(VARUINT_MIN - 1) 

168 with self.assertRaises(PythonRuntimeException): 

169 writer.write_varuint(VARUINT_MAX + 1) 

170 

171 def test_write_varsize(self): 

172 writer = BitStreamWriter() 

173 writer.write_varsize(0) 

174 self.assertEqual(8, writer.bitposition) 

175 self.assertEqual(b'\x00', writer.byte_array) 

176 with self.assertRaises(PythonRuntimeException): 

177 writer.write_varsize(VARSIZE_MIN - 1) 

178 with self.assertRaises(PythonRuntimeException): 

179 writer.write_varsize(VARSIZE_MAX + 1) 

180 

181 def test_write_float16(self): 

182 writer = BitStreamWriter() 

183 writer.write_float16(0) 

184 self.assertEqual(16, writer.bitposition) 

185 self.assertEqual(b'\x00\x00', writer.byte_array) 

186 

187 def test_write_float32(self): 

188 writer = BitStreamWriter() 

189 writer.write_float32(0) 

190 self.assertEqual(32, writer.bitposition) 

191 self.assertEqual(b'\x00\x00\x00\x00', writer.byte_array) 

192 

193 def test_write_float64(self): 

194 writer = BitStreamWriter() 

195 writer.write_float64(0) 

196 self.assertEqual(64, writer.bitposition) 

197 self.assertEqual(b'\x00\x00\x00\x00\x00\x00\x00\x00', writer.byte_array) 

198 

199 def test_write_string(self): 

200 writer = BitStreamWriter() 

201 writer.write_string("") 

202 self.assertEqual(8, writer.bitposition) # length 0 

203 self.assertEqual(b'\x00', writer.byte_array) 

204 

205 def test_write_bool(self): 

206 writer = BitStreamWriter() 

207 writer.write_bool(True) 

208 writer.write_bool(False) 

209 writer.write_bool(True) 

210 writer.write_bool(False) 

211 writer.write_bool(True) 

212 writer.write_bool(False) 

213 self.assertEqual(6, writer.bitposition) 

214 self.assertEqual(b'\xA8', writer.byte_array) 

215 

216 def test_write_bitbuffer(self): 

217 writer = BitStreamWriter() 

218 writer.write_bitbuffer(BitBuffer(bytes([0xAB, 0xE0]), 11)) 

219 writer.write_bitbuffer(BitBuffer(bytes([0x00, 0xFE]), 15)) 

220 self.assertEqual(8 + 11 + 8 + 15, writer.bitposition) 

221 self.assertEqual(b'\x0B\xAB\xE1\xE0\x1F\xC0', writer.byte_array) 

222 

223 def test_byte_array(self): 

224 writer = BitStreamWriter() 

225 self.assertEqual(b'', writer.byte_array) 

226 

227 def test_bitposition(self): 

228 writer = BitStreamWriter() 

229 self.assertEqual(0, writer.bitposition) 

230 

231 def test_alignto(self): 

232 writer = BitStreamWriter() 

233 writer.alignto(8) 

234 self.assertEqual(0, writer.bitposition) 

235 writer.alignto(2) 

236 self.assertEqual(0, writer.bitposition) 

237 writer.write_bool(True) 

238 writer.alignto(8) 

239 self.assertEqual(8, writer.bitposition) 

240 writer.write_bool(True) 

241 writer.alignto(2) 

242 self.assertEqual(10, writer.bitposition)