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

148 statements  

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

1import enum 

2import unittest 

3 

4from zserio.array import Array, SignedBitFieldArrayTraits 

5from zserio.bitbuffer import BitBuffer 

6from zserio.hashcode import (HASH_SEED, HASH_PRIME_NUMBER, calc_hashcode_bool, 

7 calc_hashcode_int32, calc_hashcode_int64, 

8 calc_hashcode_float32, calc_hashcode_float64, 

9 calc_hashcode_bytes, calc_hashcode_string, calc_hashcode_object, 

10 calc_hashcode_bool_array, calc_hashcode_int_array, 

11 calc_hashcode_float32_array, calc_hashcode_float64_array, 

12 calc_hashcode_bytes_array, calc_hashcode_string_array, calc_hashcode_object_array) 

13from zserio.float import float_to_uint32, float_to_uint64 

14 

15class Color(enum.Enum): 

16 NONE = 0 

17 RED = 2 

18 BLUE = 3 

19 BLACK = 7 

20 

21 def __hash__(self): 

22 result = HASH_SEED 

23 result = calc_hashcode_int32(result, self.value) 

24 return result 

25 

26class Permissions: 

27 def __init__(self, value): 

28 self._value = value 

29 

30 def __hash__(self): 

31 result = HASH_SEED 

32 result = calc_hashcode_int32(result, self.value) 

33 return result 

34 

35 @property 

36 def value(self): 

37 return self._value 

38 

39 class Values: 

40 READ = None 

41 WRITE = None 

42 CREATE = None 

43 

44Permissions.Values.READ = Permissions(1) 

45Permissions.Values.WRITE = Permissions(2) 

46Permissions.Values.CREATE = Permissions(4) 

47 

48class DummyObject: 

49 def __init__(self, hash_code): 

50 self._hash_code = hash_code 

51 

52 def __hash__(self): 

53 return self._hash_code 

54 

55class HashCodeTest(unittest.TestCase): 

56 

57 def test_bool_type(self): 

58 hash_seed = 1 

59 bool_value = True 

60 self.assertEqual(HASH_PRIME_NUMBER + 1, calc_hashcode_bool(hash_seed, bool_value)) 

61 

62 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bool(hash_seed, None)) 

63 

64 def test_int_type(self): 

65 hash_seed = 1 

66 int_value = 10 

67 self.assertEqual(HASH_PRIME_NUMBER + 10, calc_hashcode_int32(hash_seed, int_value)) 

68 

69 int_value = -1 

70 self.assertEqual(HASH_PRIME_NUMBER - 1, calc_hashcode_int32(hash_seed, int_value)) 

71 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int64(hash_seed, int_value)) 

72 

73 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int32(hash_seed, None)) 

74 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int64(hash_seed, None)) 

75 

76 def test_float32_type(self): 

77 hash_seed = 1 

78 float_value = 10.0 

79 self.assertEqual(HASH_PRIME_NUMBER + float_to_uint32(float_value), 

80 calc_hashcode_float32(hash_seed, float_value)) 

81 

82 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float32(hash_seed, None)) 

83 

84 def test_float64_type(self): 

85 hash_seed = 1 

86 float_value = 10.0 

87 uint64_value = float_to_uint64(float_value) 

88 expected_hash_code = ((HASH_PRIME_NUMBER + 

89 ((uint64_value & 0xFFFFFFFF) ^ ((uint64_value & 0xFFFFFFFFFFFFFFFF) >> 32))) 

90 & 0xFFFFFFFF) 

91 self.assertEqual(expected_hash_code, calc_hashcode_float64(hash_seed, float_value)) 

92 

93 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float64(hash_seed, None)) 

94 

95 def test_bytes_type(self): 

96 hash_seed = 1 

97 bytes_value = bytearray([1]) 

98 self.assertEqual(HASH_PRIME_NUMBER + 1, calc_hashcode_bytes(hash_seed, bytes_value)) 

99 

100 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bytes(hash_seed, None)) 

101 

102 def test_string_type(self): 

103 hash_seed = 1 

104 string_value = '0' 

105 self.assertEqual(HASH_PRIME_NUMBER + ord('0'), calc_hashcode_string(hash_seed, string_value)) 

106 

107 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_string(hash_seed, None)) 

108 

109 def test_bitbuffer_type(self): 

110 hash_seed = 1 

111 bitbuffer_value = BitBuffer(bytes()) 

112 self.assertEqual(HASH_PRIME_NUMBER + HASH_SEED, calc_hashcode_object(hash_seed, bitbuffer_value)) 

113 

114 def test_enum_type(self): 

115 hash_seed = 1 

116 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Color.NONE.value), 

117 calc_hashcode_object(hash_seed, Color.NONE)) 

118 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Color.RED.value), 

119 calc_hashcode_object(hash_seed, Color.RED)) 

120 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Color.BLUE.value), 

121 calc_hashcode_object(hash_seed, Color.BLUE)) 

122 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Color.BLACK.value), 

123 calc_hashcode_object(hash_seed, Color.BLACK)) 

124 

125 def test_bitmask_type(self): 

126 hash_seed = 1 

127 self.assertEqual(HASH_PRIME_NUMBER + 

128 (HASH_PRIME_NUMBER * HASH_SEED + Permissions.Values.READ.value), 

129 calc_hashcode_object(hash_seed, Permissions.Values.READ)) 

130 self.assertEqual(HASH_PRIME_NUMBER + 

131 (HASH_PRIME_NUMBER * HASH_SEED + Permissions.Values.WRITE.value), 

132 calc_hashcode_object(hash_seed, Permissions.Values.WRITE)) 

133 self.assertEqual(HASH_PRIME_NUMBER + 

134 (HASH_PRIME_NUMBER * HASH_SEED + Permissions.Values.CREATE.value), 

135 calc_hashcode_object(hash_seed, Permissions.Values.CREATE)) 

136 

137 def test_object_type(self): 

138 hash_seed = 1 

139 object_value = DummyObject(10) 

140 self.assertEqual(HASH_PRIME_NUMBER + 10, calc_hashcode_object(hash_seed, object_value)) 

141 

142 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_object(hash_seed, None)) 

143 

144 def test_array_type(self): 

145 hash_seed = 1 

146 array_value = Array(SignedBitFieldArrayTraits(32), [3, 7]) 

147 

148 raw_array_hash_code = (HASH_PRIME_NUMBER * HASH_SEED + 3) * HASH_PRIME_NUMBER + 7 

149 self.assertEqual(HASH_PRIME_NUMBER + raw_array_hash_code, calc_hashcode_object(hash_seed, array_value)) 

150 

151 def test_bool_array_type(self): 

152 hash_seed = 1 

153 bool_array_value = [ False, True ] 

154 self.assertEqual((HASH_PRIME_NUMBER + 0) * HASH_PRIME_NUMBER + 1, 

155 calc_hashcode_bool_array(hash_seed, bool_array_value)) 

156 

157 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bool_array(hash_seed, None)) 

158 

159 def test_int_array_type(self): 

160 hash_seed = 1 

161 int_array_value = [ 3, 7 ] 

162 self.assertEqual((HASH_PRIME_NUMBER + 3) * HASH_PRIME_NUMBER + 7, 

163 calc_hashcode_int_array(hash_seed, int_array_value)) 

164 

165 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int_array(hash_seed, None)) 

166 

167 def test_float32_array_type(self): 

168 hash_seed = 1 

169 float32_array_value = [ 10.0 ] 

170 self.assertEqual(HASH_PRIME_NUMBER + float_to_uint32(float32_array_value[0]), 

171 calc_hashcode_float32_array(hash_seed, float32_array_value)) 

172 

173 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float32_array(hash_seed, None)) 

174 

175 def test_float64_array_type(self): 

176 hash_seed = 1 

177 float64_array_value = [ 10.0 ] 

178 uint64_value = float_to_uint64(float64_array_value[0]) 

179 expected_hash_code = ((HASH_PRIME_NUMBER + 

180 ((uint64_value & 0xFFFFFFFF) ^ ((uint64_value & 0xFFFFFFFFFFFFFFFF) >> 32))) 

181 & 0xFFFFFFFF) 

182 self.assertEqual(expected_hash_code, calc_hashcode_float64_array(hash_seed, float64_array_value)) 

183 

184 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float64_array(hash_seed, None)) 

185 

186 def test_bytes_array_type(self): 

187 hash_seed = 1 

188 bytes_value = [ bytearray([1]) ] 

189 self.assertEqual(HASH_PRIME_NUMBER + 1, calc_hashcode_bytes_array(hash_seed, bytes_value)) 

190 

191 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bytes_array(hash_seed, None)) 

192 

193 def test_str_array_type(self): 

194 hash_seed = 1 

195 str_array_value = [ '0' ] 

196 self.assertEqual(HASH_PRIME_NUMBER + ord(str_array_value[0]), 

197 calc_hashcode_string_array(hash_seed, str_array_value)) 

198 

199 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_string_array(hash_seed, None)) 

200 

201 def test_bitbuffer_array_type(self): 

202 hash_seed = 1 

203 bitbuffer_array_value = [ BitBuffer(bytes()) ] 

204 self.assertEqual(HASH_PRIME_NUMBER + HASH_SEED, 

205 calc_hashcode_object_array(hash_seed, bitbuffer_array_value)) 

206 

207 def test_enum_array_type(self): 

208 hash_seed = 1 

209 enum_array_value = [ Color.NONE ] 

210 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Color.NONE.value), 

211 calc_hashcode_object_array(hash_seed, enum_array_value)) 

212 

213 def test_bitmask_array_type(self): 

214 hash_seed = 1 

215 bitmask_array_value = [ Permissions.Values.READ ] 

216 self.assertEqual(HASH_PRIME_NUMBER + (HASH_PRIME_NUMBER * HASH_SEED + Permissions.Values.READ.value), 

217 calc_hashcode_object_array(hash_seed, bitmask_array_value)) 

218 

219 def test_object_array_type(self): 

220 hash_seed = 1 

221 object_array_value = [ DummyObject(3), DummyObject(7) ] 

222 self.assertEqual((HASH_PRIME_NUMBER + 3) * HASH_PRIME_NUMBER + 7, 

223 calc_hashcode_object_array(hash_seed, object_array_value)) 

224 

225 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_object_array(hash_seed, None))