def test_encode_unsigned_integer(integer_value, value_bit_size,
data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError) as exception_info:
UnsignedIntegerEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedIntegerEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
lower_bound, upper_bound = compute_unsigned_integer_bounds(value_bit_size)
if not is_integer(integer_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(integer_value)
assert 'UnsignedInteger' in str(exception_info.value)
return
elif integer_value < lower_bound or integer_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(integer_value)
return
if integer_value >= 0:
expected_value = zpad(int_to_big_endian(integer_value), data_byte_size)
else:
expected_value = fpad(int_to_big_endian(integer_value), data_byte_size)
encoded_value = encoder(integer_value)
assert encoded_value == expected_value
def test_encode_unsigned_integer(integer_value, value_bit_size, data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError) as exception_info:
UnsignedIntegerEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedIntegerEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
lower_bound, upper_bound = compute_unsigned_integer_bounds(value_bit_size)
if not is_integer(integer_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(integer_value)
assert 'UnsignedInteger' in str(exception_info.value)
return
elif integer_value < lower_bound or integer_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(integer_value)
return
if integer_value >= 0:
expected_value = zpad(int_to_big_endian(integer_value), data_byte_size)
else:
expected_value = fpad(int_to_big_endian(integer_value), data_byte_size)
encoded_value = encoder(integer_value)
assert encoded_value == expected_value
def test_encode_address(address_value, value_bit_size, data_byte_size):
if value_bit_size != 20 * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
elif value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
if not is_address(address_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(address_value)
assert 'AddressEncoder' in str(exception_info.value)
return
expected_value = zpad(to_canonical_address(address_value), data_byte_size)
encoded_value = encoder(address_value)
assert encoded_value == expected_value
def test_encode_address(address_value, value_bit_size, data_byte_size):
if value_bit_size != 20 * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
elif value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = AddressEncoder(
value_bit_size=value_bit_size,
data_byte_size=data_byte_size,
)
if not is_address(address_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(address_value)
assert 'AddressEncoder' in str(exception_info.value)
return
expected_value = zpad(to_canonical_address(address_value), data_byte_size)
encoded_value = encoder(address_value)
assert encoded_value == expected_value
def encode(cls, value):
cls.validate_value(value)
base_encoded_value = cls.encode_fn(value)
if value >= 0:
padded_encoded_value = zpad(base_encoded_value, cls.data_byte_size)
else:
padded_encoded_value = fpad(base_encoded_value, cls.data_byte_size)
return padded_encoded_value
def test_encode_signed_real(base_integer_value,
value_bit_size,
high_bit_size,
low_bit_size,
data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
elif high_bit_size + low_bit_size != value_bit_size:
with pytest.raises(ValueError):
SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
if not is_number(base_integer_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(base_integer_value)
assert 'SignedReal' in str(exception_info.value)
return
unsigned_integer_value = base_integer_value % 2**(high_bit_size + low_bit_size)
with decimal.localcontext(abi_decimal_context):
real_value = decimal.Decimal(unsigned_integer_value) / 2 ** low_bit_size
lower_bound, upper_bound = compute_signed_real_bounds(
high_bit_size,
low_bit_size,
)
if real_value < lower_bound or real_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(real_value)
return
expected_value = zpad(int_to_big_endian(unsigned_integer_value), data_byte_size)
encoded_value = encoder(real_value)
assert encoded_value == expected_value
def encode(self, value):
self.validate_value(value)
base_encoded_value = self.encode_fn(value)
if value >= 0:
padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
else:
padded_encoded_value = fpad(base_encoded_value, self.data_byte_size)
return padded_encoded_value
def encode(self, value):
self.validate_value(value)
base_encoded_value = self.encode_fn(value)
if self.is_big_endian:
padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
else:
padded_encoded_value = zpad_right(base_encoded_value, self.data_byte_size)
return padded_encoded_value
def encode(cls, value):
cls.validate_value(value)
base_encoded_value = cls.encode_fn(value)
if cls.is_big_endian:
padded_encoded_value = zpad(base_encoded_value, cls.data_byte_size)
else:
padded_encoded_value = zpad_right(base_encoded_value,
cls.data_byte_size)
return padded_encoded_value
def encode(self, value):
self.validate_value(value)
base_encoded_value = self.encode_fn(value)
if value >= 0:
padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
else:
padded_encoded_value = fpad(base_encoded_value, self.data_byte_size)
return padded_encoded_value
def encode(self, value):
self.validate_value(value)
base_encoded_value = self.encode_fn(value)
if self.is_big_endian:
padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
else:
padded_encoded_value = zpad_right(base_encoded_value, self.data_byte_size)
return padded_encoded_value
def test_encode_boolean(bool_value, data_byte_size):
encoder = BooleanEncoder.as_encoder(data_byte_size=data_byte_size, )
if not is_boolean(bool_value):
with pytest.raises(EncodingTypeError):
encoder(bool_value)
return
expected_value = zpad(b'\x01' if bool_value else b'\x00', data_byte_size)
encoded_value = encoder(bool_value)
assert encoded_value == expected_value
def test_encode_unsigned_real(base_integer_value, value_bit_size,
high_bit_size, low_bit_size, data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
elif high_bit_size + low_bit_size != value_bit_size:
with pytest.raises(ValueError):
UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
if not is_number(base_integer_value):
with pytest.raises(EncodingTypeError):
encoder(base_integer_value)
return
real_value = decimal.Decimal(base_integer_value) / 2**low_bit_size
lower_bound, upper_bound = compute_unsigned_real_bounds(
high_bit_size,
low_bit_size,
)
if real_value < lower_bound or real_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(base_integer_value)
return
expected_value = zpad(int_to_big_endian(base_integer_value),
data_byte_size)
encoded_value = encoder(real_value)
assert encoded_value == expected_value
def test_encode_boolean(bool_value, data_byte_size):
encoder = BooleanEncoder(
data_byte_size=data_byte_size,
)
if not is_boolean(bool_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(bool_value)
assert 'BooleanEncoder' in str(exception_info.value)
return
expected_value = zpad(b'\x01' if bool_value else b'\x00', data_byte_size)
encoded_value = encoder(bool_value)
assert encoded_value == expected_value
def test_zpadding(value, length, expected):
actual = zpad(value, length)
assert actual == expected
def test_zpadding(value, length, expected):
actual = zpad(value, length)
assert actual == expected
