Exemple #1
0
    def Deserialize(self, reader: BinaryReader):
        """
        Deserialize full object.

        Args:
            reader (neocore.IO.BinaryReader):
        """
        super(ValidatorState, self).Deserialize(reader)
        self.PublicKey = ECDSA.Deserialize_Secp256r1(reader)
        self.Registered = reader.ReadBool()
        self.Votes = reader.ReadFixed8()
class BinaryReaderTestCase(TestCase):
    def setUp(self):
        stream = BytesIO(b"\x41\x01\x02\x03\x04")
        self.br = BinaryReader(stream)

    def test_various(self):
        self.assertEqual(self.br.unpack("c"), b"A")

        b = self.br.ReadByte()
        self.assertEqual(b, 1)

        b = self.br.ReadByte(do_ord=False)
        self.assertEqual(b, b"\x02")

        bio0 = BytesIO(b"")
        br0 = BinaryReader(bio0)
        b = br0.ReadByte()
        self.assertEqual(b, 0)
        # print("===", b)

        b = self.br.ReadBool()
        self.assertEqual(b, True)

        self.assertEqual(get_br(b"\x41").ReadChar(), b"A")

        self.assertEqual(get_br(b"1234").ReadFloat(), 1.6688933612840628e-07)
        self.assertEqual(
            get_br(b"12345678").ReadDouble(), 6.821320051701325e-38)
        self.assertEqual(get_br(b"12").ReadInt8(), 49)
        self.assertEqual(get_br(b"12").ReadUInt8(), 49)
        self.assertEqual(get_br(b"12").ReadInt16(), 12849)
        self.assertEqual(get_br(b"12").ReadUInt16(), 12849)
        self.assertEqual(get_br(b"\xff234").ReadInt32(), 875770623)
        self.assertEqual(get_br(b"\xff234").ReadUInt32(), 875770623)
        self.assertEqual(get_br(b"12345678").ReadInt64(), 4050765991979987505)
        self.assertEqual(get_br(b"12345678").ReadUInt64(), 4050765991979987505)

        self.assertEqual(get_br(b"\xfd1234abc").ReadVarBytes(), b"34abc")
        self.assertEqual(get_br(b"\x03234").ReadString(), b"234")
        self.assertEqual(get_br(b"\x03123").ReadVarString(), b"123")
        self.assertEqual(get_br(b"abc").ReadFixedString(2), b"ab")

        x = get_br(b"123871987392873918723981723987189").ReadUInt256()
        self.assertEqual(
            str(x),
            "3831373839333237313839333237383139333738323933373839313738333231")

        x = get_br(b"123871987392873918723981723987189").ReadUInt160()
        self.assertEqual(str(x), "3237383139333738323933373839313738333231")

        x = get_br(b"\x01\x02\x0345678").ReadFixed8()
        self.assertEqual(str(x), "40507659919.768295")

        self.assertEqual(
            get_br(b"\x0212345567898765434567890987").ReadHashes(),
            ['3738393039383736353433343536373839383736353534333231', ''])

    def test_varint(self):
        self.assertEqual(get_br(b"").ReadVarInt(), 0)
        self.assertEqual(get_br(b"\xfd12").ReadVarInt(), 12849)
        self.assertEqual(get_br(b"\xfe1234").ReadVarInt(), 875770417)
        self.assertEqual(
            get_br(b"\xff12345678").ReadVarInt(), 4050765991979987505)

        with self.assertRaises(Exception):
            self.assertEqual(get_br(b"\xfd1234").ReadVarInt(max=12848), 12849)

    def test_Read2000256List(self):
        val = b"1" * 64
        x = get_br(val * 2000)
        res = x.Read2000256List()
        for item in res:
            self.assertEqual(item, val)

    def test_readserializable_success(self):
        stream = BytesIO(b"\x04\x01\x02\x03\x04")
        reader = BinaryReader(stream)
        test_object_list = reader.ReadSerializableArray(
            'tests.test_io.TestObject')
        self.assertEqual(test_object_list[0].test_value, 0x4030201)

    def test_readserializable_fail(self):
        # fails because input stream is too short
        stream = BytesIO(b"\x04\x01\x02\x03")
        reader = BinaryReader(stream)
        test_object_list = reader.ReadSerializableArray(
            'tests.test_io.TestObject')
        self.assertEqual(len(test_object_list), 0)

    def test_readvarint_fail(self):
        stream = BytesIO(b"")
        reader = BinaryReader(stream)
        result = reader.ReadVarInt()
        self.assertEqual(result, 0)

    def test_saferead(self):
        self.assertNotEqual(len(get_br(b"1234").ReadBytes(10)), 10)
        with self.assertRaises(ValueError) as context:
            get_br(b"1234").SafeReadBytes(10)
        self.assertIn("Not enough data available", str(context.exception))
        self.assertEqual(
            len(get_br(b"\x01\x02\x03\x04\x05\x06\x07\x08").SafeReadBytes(8)),
            8)