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
« prev ^ index » next coverage.py v6.5.0, created at 2023-12-13 15:12 +0000
1import enum
2import unittest
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
15class Color(enum.Enum):
16 NONE = 0
17 RED = 2
18 BLUE = 3
19 BLACK = 7
21 def __hash__(self):
22 result = HASH_SEED
23 result = calc_hashcode_int32(result, self.value)
24 return result
26class Permissions:
27 def __init__(self, value):
28 self._value = value
30 def __hash__(self):
31 result = HASH_SEED
32 result = calc_hashcode_int32(result, self.value)
33 return result
35 @property
36 def value(self):
37 return self._value
39 class Values:
40 READ = None
41 WRITE = None
42 CREATE = None
44Permissions.Values.READ = Permissions(1)
45Permissions.Values.WRITE = Permissions(2)
46Permissions.Values.CREATE = Permissions(4)
48class DummyObject:
49 def __init__(self, hash_code):
50 self._hash_code = hash_code
52 def __hash__(self):
53 return self._hash_code
55class HashCodeTest(unittest.TestCase):
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))
62 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bool(hash_seed, None))
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))
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))
73 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int32(hash_seed, None))
74 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int64(hash_seed, None))
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))
82 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float32(hash_seed, None))
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))
93 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float64(hash_seed, None))
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))
100 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bytes(hash_seed, None))
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))
107 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_string(hash_seed, None))
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))
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))
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))
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))
142 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_object(hash_seed, None))
144 def test_array_type(self):
145 hash_seed = 1
146 array_value = Array(SignedBitFieldArrayTraits(32), [3, 7])
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))
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))
157 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bool_array(hash_seed, None))
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))
165 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_int_array(hash_seed, None))
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))
173 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float32_array(hash_seed, None))
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))
184 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_float64_array(hash_seed, None))
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))
191 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_bytes_array(hash_seed, None))
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))
199 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_string_array(hash_seed, None))
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))
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))
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))
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))
225 self.assertEqual(HASH_PRIME_NUMBER, calc_hashcode_object_array(hash_seed, None))