def test_dataclass_struct_nested():
meta_0 = {}
StructFieldMeta(0x0, deferred_uint8).put_into(meta_0)
meta_2 = {}
StructFieldMeta(0x2, deferred_uint8).put_into(meta_2)
@dataclass
class Inner:
field_a: int = field(metadata=meta_0)
field_b: int = field(metadata=meta_2)
def deferred_inner(path, field_type):
return DataclassStruct(path, field_type)
meta_3_inner = {}
StructFieldMeta(0x3, deferred_inner).put_into(meta_3_inner)
@dataclass
class Outer:
field_0: int = field(metadata=meta_0)
field_2: int = field(metadata=meta_2)
inner: Inner = field(metadata=meta_3_inner)
dc_outer = DataclassStruct(FieldPath(), Outer)
assert dc_outer.from_bytes(b"\x00\x01\x02\x03\x04\x05", MemContext()) == Outer(
0, 2, Inner(3, 5)
)
def test_vector_dsl():
vec_wrap_buf = (
b"\xdc" * 9 # offset 1 and unused pointer
+ b"\x01\x00\x00\x00\x00\x00\x00\x00"
+ b"\xde" * 4
+ b"\x02\x00\x00\x00"
)
arr_buf = b"\xff\x03\x00\x09\x00"
mem_type = DataclassStruct(FieldPath(), VecWrap)
mem_ctx = MemContext(BytesReader(arr_buf))
assert mem_type.from_bytes(vec_wrap_buf, mem_ctx) == VecWrap((3, 9))
def test_dataclass_struct_scalar_c_error_passthrough():
meta_0 = {}
StructFieldMeta(0x0, deferred_uint8).put_into(meta_0)
@dataclass
class MyStruct:
field_a: FourEnum = field(metadata=meta_0)
dc_struct = DataclassStruct(FieldPath(), MyStruct)
with pytest.raises(ScalarCValueConstructionError):
dc_struct.from_bytes(b"\x00", MemContext())
def test_dataclass_struct_general_error():
meta_0 = {}
StructFieldMeta(0x0, deferred_uint8).put_into(meta_0)
@dataclass
class MyStruct:
field_a: FourEnum = field(metadata=meta_0)
dc_struct = DataclassStruct(FieldPath(), MyStruct)
with pytest.raises(ValueError):
# Too few bytes in buffer
dc_struct.from_bytes(b"", MemContext())
def test_state():
state_mt = DataclassStruct(FieldPath(), State)
state_bytes = b"\x05\xff\x00\x01\x01\x63\x2a\xff\x08\x01\xff\x02\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00" # pylint: disable=line-too-long
mem_ctx = MemContext(BytesReader(b"\x00\x00\x03\x01\x0f\x08"))
expected = State(
5,
(False, True, True),
frozenset([Player(99, 42), Player(8, 1)]),
259,
PolyPointer(4, Player(15, 8), mem_ctx),
)
assert state_mt.from_bytes(state_bytes, mem_ctx) == expected
def __post_init__(self, path, py_type):
if py_type is not UidEntityMap:
raise ValueError(
f"field {path} must be UnorderedMap, got {py_type}")
meta_mem_type = DataclassStruct(path, _RobinHoodTableMeta)
poly_entity_mem_type = PolyPointerType(path, PolyPointer[Entity],
dc_struct)
table_entry_mem_type = DataclassStruct(path, _RobinHoodTableEntry)
object.__setattr__(self, "meta_mem_type", meta_mem_type)
object.__setattr__(self, "poly_entity_mem_type", poly_entity_mem_type)
object.__setattr__(self, "table_entry_mem_type", table_entry_mem_type)
def test_dataclass_struct_simple():
meta_0 = {}
StructFieldMeta(0x0, deferred_uint8).put_into(meta_0)
meta_3 = {}
StructFieldMeta(0x3, deferred_uint8).put_into(meta_3)
@dataclass
class MyStruct:
field_a: int = field(metadata=meta_0)
field_b: int = field(metadata=meta_3)
dc_struct = DataclassStruct(FieldPath(), MyStruct)
assert dc_struct.from_bytes(b"\x00\x01\x02\x03", MemContext()) == MyStruct(0, 3)
def __post_init__(self, py_type, deferred_elem_mem_type):
opt_inner_type = unwrap_optional_type(self.path, py_type)
collection_type, elem_py_type = unwrap_collection_type(
self.path, opt_inner_type
)
elem_mem_type = deferred_elem_mem_type(self.path, elem_py_type)
vector_meta_mem_type = DataclassStruct(
self.path.append("__vector_meta"), _VectorMeta
)
object.__setattr__(self, "collection_type", collection_type)
object.__setattr__(self, "elem_mem_type", elem_mem_type)
object.__setattr__(self, "vector_meta_mem_type", vector_meta_mem_type)
def __post_init__(self, py_type, key_deferred_mem_type, val_deferred_mem_type):
key_py_type, val_py_type = self._unwrap_unordered_map(self.path, py_type)
key_mem_type = key_deferred_mem_type(self.path, key_py_type)
val_mem_type = val_deferred_mem_type(self.path, val_py_type)
um_meta_mem_type = DataclassStruct(self.path, _UnorderedMapMeta)
try:
# This is implied by BiMemType, but it's easy to accidentally use a
# MemType instead.
key_mem_type.to_bytes
except (AttributeError, NotImplementedError) as err:
raise ValueError(
f"key for field {self.path} must implement BiMemType.to_bytes"
) from err
node_mem_type = _UnorderedMapNodeType(key_mem_type, val_mem_type)
object.__setattr__(self, "key_mem_type", key_mem_type)
object.__setattr__(self, "val_mem_type", val_mem_type)
object.__setattr__(self, "node_mem_type", node_mem_type)
object.__setattr__(self, "um_meta_mem_type", um_meta_mem_type)
def deferred_inner(path, field_type):
return DataclassStruct(path, field_type)
def test_player():
player_mt = DataclassStruct(FieldPath(), Player)
state_bytes = b"\x10\x20"
assert player_mt.from_bytes(state_bytes, MemContext()) == Player(16, 32)