def test_out_of_range_values_pack(self):
"""Test packing invalid enum values."""
test_bitfield = BitField(SimpleEnum)
field = ('a', 'b', test_bitfield) # signed byte: -128, 127
out = ElementBitField.valid(field)
self.assertTrue(out)
elem = ElementBitField(field)
test_values = [
({'a': -1}, -1),
({'a': 3}, 3),
({'a': [0, SimpleEnum.one]}, 0),
({'a': [SimpleEnum.one, -1]}, -1),
({'a': [SimpleEnum.two, 3]}, 3),
({'a': ['TWO']}, 'TWO'),
]
msg = '{} is not a valid {}'
for (in_val, bad_val) in test_values:
with self.subTest((in_val, bad_val)): # pylint: disable=no-member
with self.assertRaises(ValueError) as cm:
elem.pack(in_val)
self.assertEqual(str(cm.exception), msg.format(bad_val, 'SimpleEnum'))
def test_valid_pack(self):
"""Test packing valid enum values."""
test_bitfield = BitField(SimpleEnum)
field = ('a', 'B', test_bitfield) # unsigned byte: 0, 256
out = ElementBitField.valid(field)
self.assertTrue(out)
elem = ElementBitField(field)
test_values = [
({'a': 2}, b'\x02'),
({'a': []}, b'\x00'),
({'a': None}, b'\x00'),
({'a': [SimpleEnum.one]}, b'\x01'),
({'a': ['one']}, b'\x01'),
({'a': [SimpleEnum.two]}, b'\x02'),
({'a': [SimpleEnum.one, SimpleEnum.two]}, b'\x03'),
({'a': [1, SimpleEnum.two]}, b'\x03'),
({'a': [1, SimpleEnum.two, 'four']}, b'\x07'),
]
for (in_val, out_val) in test_values:
with self.subTest((out_val, in_val)): # pylint: disable=no-member
ret = elem.pack(in_val)
self.assertEqual(ret, out_val)
test_packedbitfield = PackedBitField(SimpleEnumWithZero, test_bitfield)
field = ('a', 'B', test_packedbitfield) # unsigned byte: 0, 256
out = ElementBitField.valid(field)
self.assertTrue(out)
self.assertEqual(list(test_packedbitfield._fields.keys()), [SimpleEnumWithZero, test_bitfield])
self.assertEqual(test_packedbitfield._fields[test_bitfield], {'offset': 0, 'mask': 0x07, 'width': 3})
self.assertEqual(test_packedbitfield._fields[SimpleEnumWithZero], {'offset': 3, 'mask': 0x18, 'width': 2})
elem = ElementBitField(field)
test_values = [
({'a': []}, b'\x00'),
({'a': None}, b'\x00'),
({'a': 0}, b'\x00'), # 0 is a valid SimpleEnumWithZero
({'a': 4}, b'\x04'),
({'a': [SimpleEnum.one]}, b'\x01'),
({'a': [SimpleEnum.two]}, b'\x02'),
({'a': [SimpleEnum.one, SimpleEnum.two]}, b'\x03'),
({'a': ['zero', SimpleEnumWithZero.one, SimpleEnum.two]}, b'\x0a'),
({'a': [SimpleEnumWithZero.two, 'four']}, b'\x14'),
]
for (in_val, out_val) in test_values:
with self.subTest((out_val, in_val)): # pylint: disable=no-member
ret = elem.pack(in_val)
self.assertEqual(ret, out_val)
def test_out_of_range_values_pack(self):
"""Test packing invalid enum values."""
test_bitfield = BitField(SimpleEnum)
field = ('a', 'B', test_bitfield) # unsigned byte: 0, 256
out = ElementBitField.valid(field)
self.assertTrue(out)
elem = ElementBitField(field)
test_values = [
({'a': -1}, -1),
({'a': 3}, 3),
({'a': 0}, 0),
({'a': [0, SimpleEnum.one]}, 0),
({'a': [SimpleEnum.one, -1]}, -1),
({'a': [SimpleEnum.two, 3]}, 3),
({'a': ['TWO']}, 'TWO'),
]
msg = '{} is not a valid {}'
for (in_val, bad_val) in test_values:
with self.subTest((in_val, bad_val)): # pylint: disable=no-member
with self.assertRaises(ValueError) as cm:
elem.pack(in_val)
self.assertEqual(str(cm.exception), msg.format(bad_val, 'SimpleEnum'))
test_packedbitfield = PackedBitField(SimpleEnumWithZero, test_bitfield)
field = ('a', 'B', test_packedbitfield) # unsigned byte: 0, 256
out = ElementBitField.valid(field)
self.assertTrue(out)
elem = ElementBitField(field)
test_values = [
({'a': -1}, 'valid', -1),
({'a': 3}, 'valid', 3),
({'a': ['one']}, 'unique', 'one'),
({'a': [1, SimpleEnum.two]}, 'unique', 1),
({'a': [1, SimpleEnum.two, 'four']}, 'unique', 1),
({'a': [SimpleEnumWithZero.one, -1]}, 'valid', -1),
({'a': ['TWO']}, 'valid', 'TWO'),
]
msg = '{} is not a {} {}'
for (in_val, err_str, bad_val) in test_values:
with self.subTest((in_val, err_str, bad_val)): # pylint: disable=no-member
with self.assertRaises(ValueError) as cm:
elem.pack(in_val)
self.assertEqual(str(cm.exception), msg.format(bad_val, err_str, [SimpleEnumWithZero, test_bitfield]))
def test_valid_pack(self):
"""Test packing valid enum values."""
test_bitfield = BitField(SimpleEnum)
field = ('a', 'b', test_bitfield) # signed byte: -128, 127
out = ElementBitField.valid(field)
self.assertTrue(out)
elem = ElementBitField(field)
test_values = [
({'a': 2}, b'\x02'),
({'a': []}, b'\x00'),
({'a': None}, b'\x00'),
({'a': 0}, b'\x00'), # 0 is treated the same as None or an empty list
({'a': [SimpleEnum.one]}, b'\x01'),
({'a': ['one']}, b'\x01'),
({'a': [SimpleEnum.two]}, b'\x02'),
({'a': [SimpleEnum.one, SimpleEnum.two]}, b'\x03'),
({'a': [1, SimpleEnum.two]}, b'\x03'),
({'a': [1, SimpleEnum.two, 'four']}, b'\x07'),
]
for (in_val, out_val) in test_values:
with self.subTest((out_val, in_val)): # pylint: disable=no-member
ret = elem.pack(in_val)
self.assertEqual(ret, out_val)
