Method test_custom_serializer_and_deserializer

Lib/test/test_shelve.py:169–225

(self)

            self.assertEqual(s._protocol, pickle.DEFAULT_PROTOCOL)

    def test_custom_serializer_and_deserializer(self):
        os.mkdir(self.dirname)
        self.addCleanup(os_helper.rmtree, self.dirname)

        def serializer(obj, protocol):
            if isinstance(obj, (bytes, bytearray, str)):
                if protocol == 5:
                    if isinstance(obj, bytearray):
                        return bytes(obj)  # DBM backends expect bytes
                    return obj
                return type(obj).__name__
            elif isinstance(obj, array.array):
                return obj.tobytes()
            raise TypeError(f"Unsupported type for serialization: {type(obj)}")

        def deserializer(data):
            if isinstance(data, (bytes, bytearray, str)):
                return data.decode("utf-8")
            elif isinstance(data, array.array):
                return array.array("b", data)
            raise TypeError(
                f"Unsupported type for deserialization: {type(data)}"
            )

        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
            with self.subTest(proto=proto), shelve.open(
                self.fn,
                protocol=proto,
                serializer=serializer,
                deserializer=deserializer
            ) as s:
                bar = "bar"
                bytes_data = b"Hello, world!"
                bytearray_data = bytearray(b"\x00\x01\x02\x03\x04")
                array_data = array.array("i", [1, 2, 3, 4, 5])

                s["foo"] = bar
                s["bytes_data"] = bytes_data
                s["bytearray_data"] = bytearray_data
                s["array_data"] = array_data

                if proto == 5:
                    self.assertEqual(s["foo"], str(bar))
                    self.assertEqual(s["bytes_data"], "Hello, world!")
                    self.assertEqual(
                        s["bytearray_data"], bytearray_data.decode()
                    )
                    self.assertEqual(
                        s["array_data"], array_data.tobytes().decode()
                    )
                else:
                    self.assertEqual(s["foo"], "str")
                    self.assertEqual(s["bytes_data"], "bytes")
                    self.assertEqual(s["bytearray_data"], "bytearray")
                    self.assertEqual(
                        s["array_data"], array_data.tobytes().decode()
                    )