def reserved_bytes(self) -> [bytes]:
reserved_int: int = from_byte(self.reserved_byte)
return [to_byte(reserved_int),
to_byte(reserved_int + 1),
to_byte(reserved_int + 2),
to_byte(reserved_int + 3)]
def test_123b(self):
codec: Codec[bytes] = BytesCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, to_byte(123))
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), to_byte(123))
reader.close()
def write_size(self, size: int, value: bytes) -> None:
if size < 65772:
if size < 256:
self.write(value)
self.write1(size - 128)
else:
self.write(to_byte(from_byte(value) + 1))
self.write2(size - 33024)
elif size < 16842988:
self.write(to_byte(from_byte(value) + 2))
self.write3(size - 8454380)
else:
self.write(to_byte(from_byte(value) + 3))
self.write4(size - 8454380)
def char_seria(self, value: None or str):
codec: Codec[str] = CharCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), value)
reader.close()
def boolean_seria(self, value: None or bool):
codec: Codec[bool] = BooleanCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), value)
reader.close()
def short_seria(self, value: None or List[int]):
codec: Codec[float] = ShortArrayCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), value)
reader.close()
def bytes_seria(self, value: None or List[bool]):
codec: Codec[bytes] = ByteArrayCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), value)
reader.close()
def float_seria(self, value: None or float):
codec: Codec[float] = DoubleCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
pim: float = codec.read(reader)
self.assertEqual(pim, value)
reader.close()
def int_seria(self, value: None or int):
codec: Codec[int] = IntCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
pim: int = codec.read(reader)
self.assertEqual(value, pim)
reader.close()
def string_seria(self, value: None or str):
codec: Codec[str] = StringCodec(to_byte(12), 0)
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
pim: int = codec.read(reader)
self.assertEqual(value, pim)
reader.close()
def test_false(self):
codec: Codec[bool] = BooleanCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, False)
writer.close()
reader: ByteIo = self.reader()
self.assertFalse(codec.read(reader))
reader.close()
def test_kanji(self):
codec: Codec[str] = CharCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, "字")
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), "字")
reader.close()
def read_size(self, value: bytes) -> int or None:
read: bytes = self.read()
if read is to_byte(0):
return None
length: int = from_byte(read) - from_byte(value)
if length == 0:
return from_byte(self.read())
if length == 1:
return int_from_byte(self.read(2)) + 33024
if length == 2:
return int_from_byte(self.read(3)) + 8454380
if length == 3:
return int_from_byte(self.read(4))
raise ValueError("Could not deserialize size")
def float_seria(self, value: None or List[float]):
codec: Codec[float] = FloatArrayCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, value)
writer.close()
reader: ByteIo = self.reader()
read: None or List[float] = codec.read(reader)
if value is None:
self.assertIsNone(read)
else:
self.assertEqual(len(value), len(read))
for i in range(0, len(value)):
self.assertGreaterEqual(value[i], read[i] - 0.1)
self.assertLessEqual(value[i], read[i] + 0.1)
reader.close()
def test_mix(self):
codec: Codec[bool] = BooleanCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, False)
codec.write(writer, True)
codec.write(writer, True)
codec.write(writer, None)
codec.write(writer, False)
codec.write(writer, True)
writer.close()
reader: ByteIo = self.reader()
self.assertFalse(codec.read(reader))
self.assertTrue(codec.read(reader))
self.assertTrue(codec.read(reader))
self.assertEqual(codec.read(reader), None)
self.assertFalse(codec.read(reader))
self.assertTrue(codec.read(reader))
reader.close()
def test_mix(self):
codec: Codec[str] = CharCodec(to_byte(12))
writer: ByteIo = self.writer()
codec.write(writer, "a")
codec.write(writer, "文")
codec.write(writer, "字")
codec.write(writer, None)
codec.write(writer, "漢")
codec.write(writer, "字")
writer.close()
reader: ByteIo = self.reader()
self.assertEqual(codec.read(reader), "a")
self.assertEqual(codec.read(reader), "文")
self.assertEqual(codec.read(reader), "字")
self.assertEqual(codec.read(reader), None)
self.assertEqual(codec.read(reader), "漢")
self.assertEqual(codec.read(reader), "字")
reader.close()
def test_find_ser(self) -> None:
cache: CodecCache = CodecCache()
cache.register(BooleanCodec(cache.next_free_marker()))
cache.register(BytesCodec(cache.next_free_marker()))
cache.register(CharCodec(cache.next_free_marker()))
cache.register(StringCodec(cache.next_free_marker(), 0))
cache.register(DoubleCodec(cache.next_free_marker()))
cache.register(FloatCodec(cache.next_free_marker()))
cache.register(IntCodec(cache.next_free_marker()))
cache.register(LongCodec(cache.next_free_marker()))
cache.register(ShortCodec(cache.next_free_marker()))
cache.register(BooleanArrayCodec(cache.next_free_marker()))
cache.register(ByteArrayCodec(cache.next_free_marker()))
self.assertIsInstance(cache.codec_for(True), BooleanCodec)
self.assertIsInstance(cache.codec_for(to_byte(12)), ByteArrayCodec)
self.assertIsInstance(cache.codec_for(None), NoneCodec)
self.assertIsInstance(cache.codec_for("a"), StringCodec)
self.assertIsInstance(cache.codec_for(12), LongCodec)
self.assertIsInstance(cache.codec_for(1.2), DoubleCodec)
class NoneCodec(Codec[None]):
"""Codec for the None type"""
NONE_VALUE: bytes = to_byte(0)
"""Special value used to encode 'None'"""
def __init__(self):
super().__init__()
def read(self, io: ByteIo) -> None:
if io.read() != NoneCodec.NONE_VALUE:
raise TypeError("Could not deserialize as null.")
return None
def write(self, io: ByteIo, value: None) -> None:
io.write(NoneCodec.NONE_VALUE)
def reserved_bytes(self) -> [bytes]:
return [NoneCodec.NONE_VALUE]
def writes(self, typez: type) -> bool:
if typez is type(None):
return True
return False
def test_type_check(self):
codec: Codec[bool] = BooleanCodec(to_byte(12))
self.assertTrue(codec.writes(bool))
self.assertFalse(codec.writes(str))
def test_wide_range(self):
self.byte_seria(None)
for i in range(0, 255):
self.byte_seria(to_byte(i))
def test_type_check(self):
codec: Codec[str] = CharCodec(to_byte(12))
self.assertFalse(codec.writes(bool))
# Interop
self.assertFalse(codec.writes(str))
self.assertFalse(codec.writes(bytes))
