up.done()
self.assertRaises(EOFError, up.unpack_uint)
+class ConversionErrorTest(unittest.TestCase):
+
+ def setUp(self):
+ self.packer = xdrlib.Packer()
+
+ def assertRaisesConversion(self, *args):
+ self.assertRaises(xdrlib.ConversionError, *args)
+
+ def test_pack_int(self):
+ self.assertRaisesConversion(self.packer.pack_int, 'string')
+
+ def test_pack_uint(self):
+ self.assertRaisesConversion(self.packer.pack_uint, 'string')
+
+ def test_float(self):
+ self.assertRaisesConversion(self.packer.pack_float, 'string')
+
+ def test_double(self):
+ self.assertRaisesConversion(self.packer.pack_double, 'string')
+
+ def test_uhyper(self):
+ self.assertRaisesConversion(self.packer.pack_uhyper, 'string')
+
def test_main():
support.run_unittest(XDRTest)
+ support.run_unittest(ConversionErrorTest)
if __name__ == "__main__":
test_main()
import struct
from io import BytesIO
+from functools import wraps
__all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
class ConversionError(Error):
pass
+def raise_conversion_error(function):
+ """ Wrap any raised struct.errors in a ConversionError. """
+
+ @wraps(function)
+ def result(self, value):
+ try:
+ return function(self, value)
+ except struct.error as e:
+ raise ConversionError(e.args[0]) from None
+ return result
class Packer:
# backwards compatibility
get_buf = get_buffer
+ @raise_conversion_error
def pack_uint(self, x):
self.__buf.write(struct.pack('>L', x))
+ @raise_conversion_error
def pack_int(self, x):
self.__buf.write(struct.pack('>l', x))
else: self.__buf.write(b'\0\0\0\0')
def pack_uhyper(self, x):
- self.pack_uint(x>>32 & 0xffffffff)
- self.pack_uint(x & 0xffffffff)
+ try:
+ self.pack_uint(x>>32 & 0xffffffff)
+ except (TypeError, struct.error) as e:
+ raise ConversionError(e.args[0]) from None
+ try:
+ self.pack_uint(x & 0xffffffff)
+ except (TypeError, struct.error) as e:
+ raise ConversionError(e.args[0]) from None
pack_hyper = pack_uhyper
+ @raise_conversion_error
def pack_float(self, x):
- try: self.__buf.write(struct.pack('>f', x))
- except struct.error as msg:
- raise ConversionError(msg)
+ self.__buf.write(struct.pack('>f', x))
+ @raise_conversion_error
def pack_double(self, x):
- try: self.__buf.write(struct.pack('>d', x))
- except struct.error as msg:
- raise ConversionError(msg)
+ self.__buf.write(struct.pack('>d', x))
def pack_fstring(self, n, s):
if n < 0: