示例#1
0
    def to_object(self, data):
        """Deserialize input data

        Args:
            data (hazelcast.serialization.data.Data): Serialized input Data object

        Returns:
            any: Deserialized object
        """
        if not isinstance(data, Data):
            return data

        if data.data_size() == 0 and data.get_type() == CONSTANT_TYPE_NULL:
            return None

        inp = _ObjectDataInput(data.buffer, DATA_OFFSET, self,
                               self._is_big_endian)
        try:
            type_id = data.get_type()
            serializer = self._registry.serializer_by_type_id(type_id)
            if serializer is None:
                if self._active:
                    raise HazelcastSerializationError(
                        "Missing Serializer for type-id:%s" % type_id)
                else:
                    raise HazelcastInstanceNotActiveError()
            return serializer.read(inp)
        except:
            handle_exception(sys.exc_info()[1], sys.exc_info()[2])
 def test_char_le(self):
     buff = bytearray(binascii.unhexlify("e7000000"))
     _input = _ObjectDataInput(buff, 0, None, False)
     initial_pos = _input._pos
     char = _input.read_char()
     self.assertEqual(0, initial_pos)
     self.assertEqual(unichr(0x00e7), char)
 def test_char_le(self):
     buff = bytearray(binascii.unhexlify("e7000000"))
     _input = _ObjectDataInput(buff, 0, None, False)
     initial_pos = _input._pos
     char = _input.read_char()
     self.assertEqual(0, initial_pos)
     self.assertEqual(chr(0x00E7), char)
 def test_bool_array(self):
     buff = bytearray(binascii.unhexlify("0000000400010101"))
     _input = _ObjectDataInput(buff, 0, None, True)
     initial_pos = _input._pos
     read_arr = _input.read_boolean_array()
     self.assertEqual(0, initial_pos)
     self.assertEqual(self.BOOL_ARR, read_arr)
 def test_short_array(self):
     buff = bytearray(binascii.unhexlify("000000040001000200030004"))
     _input = _ObjectDataInput(buff, 0, None, True)
     initial_pos = _input._pos
     read_arr = _input.read_short_array()
     self.assertEqual(0, initial_pos)
     self.assertEqual(self.INT_ARR, read_arr)
 def test_bool_array(self):
     buff = bytearray(binascii.unhexlify("0000000400010101"))
     _input = _ObjectDataInput(buff, 0, None, True)
     initial_pos = _input._pos
     read_arr = _input.read_boolean_array()
     self.assertEqual(0, initial_pos)
     self.assertEqual(self.BOOL_ARR, read_arr)
 def test_short_array(self):
     buff = bytearray(binascii.unhexlify("000000040001000200030004"))
     _input = _ObjectDataInput(buff, 0, None, True)
     initial_pos = _input._pos
     read_arr = _input.read_short_array()
     self.assertEqual(0, initial_pos)
     self.assertEqual(self.INT_ARR, read_arr)
    def test_read_boolean_array(self):
        b = bytearray([0, 0, 0, 2, 0, 1])
        inp = _ObjectDataInput(b)
        self.assertEqual([False, True], inp.read_boolean_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_boolean_array()
    def test_read_i8_array(self):
        b = bytearray([0, 0, 0, 3, 1, 127, 255])
        inp = _ObjectDataInput(b)
        self.assertEqual([1, 127, -1], inp.read_i8_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_i8_array()
示例#10
0
    def test_read_byte_array(self):
        b = bytearray([0, 0, 0, 10] + list(range(10)))
        inp = _ObjectDataInput(b)
        self.assertEqual(b[4:], inp.read_byte_array())  # skip length
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_byte_array()
示例#11
0
    def test_read_char_array(self):
        b = bytearray([0, 0, 0, 2, 0, 97, 0, 49])
        inp = _ObjectDataInput(b)
        self.assertEqual(["a", "1"], inp.read_char_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_char_array()
示例#12
0
    def test_read_int_array(self):
        b = bytearray([0, 0, 0, 2, 127, 255, 255, 255, 128, 0, 0, 0])
        inp = _ObjectDataInput(b)
        self.assertEqual([2147483647, -2147483648], inp.read_int_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_int_array()
示例#13
0
    def test_read_short_array(self):
        b = bytearray([0, 0, 0, 2, 91, 160, 164, 96])
        inp = _ObjectDataInput(b)
        self.assertEqual([23456, -23456], inp.read_short_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_short_array()
示例#14
0
    def test_read_utf_array(self):
        b = bytearray([0, 0, 0, 1, 0, 0, 0, 3, 97, 98, 99])
        inp = _ObjectDataInput(b)
        self.assertEqual(["abc"], inp.read_utf_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_utf_array()
示例#15
0
    def test_read_long_array(self):
        b = bytearray([0, 0, 0, 1, 127, 255, 255, 255, 255, 255, 255, 255])
        inp = _ObjectDataInput(b)
        self.assertEqual([9223372036854775807], inp.read_long_array())
        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_long_array()
示例#16
0
    def test_read_short_positional(self):
        inp = _ObjectDataInput(bytearray([91, 160, 164, 96, 0, 49]))
        self.assertEqual(23456, inp.read_short_positional(0))
        self.assertEqual(-23456, inp.read_short_positional(2))
        self.assertEqual(49, inp.read_short_positional(4))
        self.assertEqual(0, inp.position())

        with self.assertRaises(EOFError):
            inp.read_short_positional(100)
示例#17
0
    def test_read_char(self):
        inp = _ObjectDataInput(bytearray([0, 97, 10, 42, 0, 49]))
        self.assertEqual("a", inp.read_char())
        self.assertEqual("ਪ", inp.read_char())
        self.assertEqual("1", inp.read_char())
        self.assertEqual(6, inp.position())

        with self.assertRaises(EOFError):
            inp.read_char()
示例#18
0
    def test_read_boolean_positional(self):
        inp = _ObjectDataInput(bytearray([0, 1, 0]))
        self.assertFalse(inp.read_boolean_positional(0))
        self.assertTrue(inp.read_boolean_positional(1))
        self.assertFalse(inp.read_boolean_positional(2))
        self.assertEqual(0, inp.position())

        with self.assertRaises(EOFError):
            inp.read_boolean_positional(100)
示例#19
0
    def test_read_unsigned_short(self):
        inp = _ObjectDataInput(bytearray([91, 160, 164, 96, 0, 49]))
        self.assertEqual(23456, inp.read_unsigned_short())
        self.assertEqual(42080, inp.read_unsigned_short())
        self.assertEqual(49, inp.read_unsigned_short())
        self.assertEqual(6, inp.position())

        with self.assertRaises(EOFError):
            inp.read_unsigned_short()
示例#20
0
    def test_read_int_positional(self):
        inp = _ObjectDataInput(
            bytearray([127, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 42]))
        self.assertEqual(2147483647, inp.read_int_positional(0))
        self.assertEqual(-2147483648, inp.read_int_positional(4))
        self.assertEqual(42, inp.read_int_positional(8))
        self.assertEqual(0, inp.position())

        with self.assertRaises(EOFError):
            inp.read_int_positional(100)
示例#21
0
    def test_read_float(self):
        inp = _ObjectDataInput(
            bytearray([66, 42, 0, 0, 195, 221, 51, 51, 73, 116, 30, 80]))
        self.assertAlmostEqual(42.5, inp.read_float(), delta=0.00001)
        self.assertAlmostEqual(-442.4, inp.read_float(), delta=0.00001)
        self.assertAlmostEqual(999909, inp.read_float(), delta=0.00001)
        self.assertEqual(12, inp.position())

        with self.assertRaises(EOFError):
            inp.read_float()
示例#22
0
    def test_read_utf(self):
        inp = _ObjectDataInput(
            bytearray([0, 0, 0, 3, 97, 98, 99, 0, 0, 0, 4, 240, 159, 145,
                       185]))
        self.assertEqual("abc", inp.read_utf())
        self.assertEqual("👹", inp.read_utf())
        self.assertEqual(15, inp.position())

        with self.assertRaises(EOFError):
            inp.read_utf()
示例#23
0
    def test_read_unsigned_byte(self):
        inp = _ObjectDataInput(bytearray([0, 255, 127, 128, 42]))
        self.assertEqual(0, inp.read_unsigned_byte())
        self.assertEqual(255, inp.read_unsigned_byte())
        self.assertEqual(127, inp.read_unsigned_byte())
        self.assertEqual(128, inp.read_unsigned_byte())
        self.assertEqual(42, inp.read_unsigned_byte())
        self.assertEqual(5, inp.position())

        with self.assertRaises(EOFError):
            inp.read_unsigned_byte()
示例#24
0
    def test_read_byte_positional(self):
        inp = _ObjectDataInput(bytearray([0, 255, 127, 128, 42]))
        self.assertEqual(0, inp.read_byte_positional(0))
        self.assertEqual(-1, inp.read_byte_positional(1))
        self.assertEqual(127, inp.read_byte_positional(2))
        self.assertEqual(-128, inp.read_byte_positional(3))
        self.assertEqual(42, inp.read_byte_positional(4))
        self.assertEqual(0, inp.position())

        with self.assertRaises(EOFError):
            inp.read_boolean_positional(100)
示例#25
0
    def test_read_long_positional(self):
        inp = _ObjectDataInput(
            bytearray([
                127, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0,
                0
            ]))
        self.assertEqual(9223372036854775807, inp.read_long_positional(0))
        self.assertEqual(-9223372036854775808, inp.read_long_positional(8))
        self.assertEqual(0, inp.position())

        with self.assertRaises(EOFError):
            inp.read_long_positional(100)
示例#26
0
    def test_read_double(self):
        inp = _ObjectDataInput(
            bytearray([
                64, 200, 28, 214, 230, 49, 248, 161, 192, 248, 28, 214, 233,
                225, 176, 138
            ]))
        self.assertAlmostEqual(12345.6789, inp.read_double(), delta=0.00001)
        self.assertAlmostEqual(-98765.4321, inp.read_double(), delta=0.00001)
        self.assertEqual(16, inp.position())

        with self.assertRaises(EOFError):
            inp.read_double()
示例#27
0
    def test_read_double_array(self):
        b = bytearray([0, 0, 0, 1, 64, 200, 28, 214, 230, 49, 248, 161])
        inp = _ObjectDataInput(b)
        expected = [12345.6789]
        actual = inp.read_double_array()
        self.assertEqual(1, len(actual))
        for expected_item, actual_item in zip(expected, actual):
            self.assertAlmostEqual(expected_item, actual_item, delta=0.00001)

        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_double_array()
示例#28
0
    def test_read_float_array(self):
        b = bytearray(
            [0, 0, 0, 3, 66, 42, 0, 0, 195, 221, 51, 51, 73, 116, 30, 80])
        inp = _ObjectDataInput(b)
        expected = [42.5, -442.4, 999909]
        actual = inp.read_float_array()
        self.assertEqual(3, len(actual))
        for expected_item, actual_item in zip(expected, actual):
            self.assertAlmostEqual(expected_item, actual_item, delta=0.00001)

        self.assertEqual(len(b), inp.position())

        with self.assertRaises(EOFError):
            inp.read_float_array()
    def setUp(self):
        config1 = _Config()
        config1.portable_factories = {FACTORY_ID: the_factory_1}

        config2 = _Config()
        config2.portable_factories = {FACTORY_ID: the_factory_2}

        self.service1 = SerializationServiceV1(config1)
        self.service2 = SerializationServiceV1(config2)

        base_portable = create_portable()
        data = self.service1.to_data(base_portable)

        inp = _ObjectDataInput(data.buffer, DATA_OFFSET, self.service2,
                               self.service2._is_big_endian)
        portable_serializer = self.service2._registry._portable_serializer
        self.reader = portable_serializer.create_morphing_reader(inp)
示例#30
0
    def setUpClass(cls):
        data_map = dict()
        here = path.abspath(path.dirname(__file__))
        with open(path.join(here, FILE_NAME), "rb") as f:
            inp = _ObjectDataInput(f.read())

        while inp.position() < inp.size():
            utf_len = inp.read_unsigned_short()
            object_key_buf = bytearray(utf_len)
            inp.read_into(object_key_buf)
            object_key = object_key_buf.decode()
            n = inp.read_int()
            if n != NULL_LENGTH:
                buf = bytearray(n)
                inp.read_into(buf)
                data_map[object_key] = Data(buf)
            else:
                data_map[object_key] = None

        cls.data_map = data_map
 def test_skip_bytes_when_count_is_not_positive(self):
     inp = _ObjectDataInput(bytearray(10))
     self.assertEqual(0, inp.skip_bytes(0))
     self.assertEqual(0, inp.position())
     self.assertEqual(0, inp.skip_bytes(-1))
     self.assertEqual(0, inp.position())
 def test_skip_bytes_when_count_greater_than_remaining(self):
     inp = _ObjectDataInput(bytearray(10))
     inp.set_position(8)
     self.assertEqual(2, inp.skip_bytes(4))
     self.assertEqual(10, inp.position())
 def test_skip_bytes(self):
     inp = _ObjectDataInput(bytearray(10))
     self.assertEqual(0, inp.position())
     self.assertEqual(4, inp.skip_bytes(4))
     self.assertEqual(4, inp.position())
 def _create_data_input(self, data):
     return _ObjectDataInput(data._buffer, DATA_OFFSET, self, self._is_big_endian)