182 lines
9.8 KiB
Python
182 lines
9.8 KiB
Python
import sys
|
|
sys.path.append('src/')
|
|
|
|
from protocol_components.dtypes import BprotoFieldBaseType
|
|
from nameHandling.base import ComponentName, NameStyleBproto
|
|
from protocol_components.message import FactoryMessage
|
|
from protocol_components.enumeration import FactoryEnumeration, Enumeration
|
|
from protocol_components.bitfields import FactoryBitfield, Bitfield
|
|
from protocol_components.protocolFactory import FactoryProtocolDefition
|
|
from protocol_components.field import FactoryField, Field, FieldEnum, FieldBitfield, FieldEnumRef, FieldBitfieldRef
|
|
from errors import BprotoUnresolvedReferenceError, BprotoAlreadyDefinedError
|
|
|
|
from nameHandling.resolver import ProtocolReferenceResolver
|
|
|
|
|
|
def test_protocol_factory():
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_message(FactoryMessage().assemble("Message1", 42))
|
|
factory.add_message(FactoryMessage().assemble("Message2", 43))
|
|
|
|
message_with_fields_factory = FactoryMessage()
|
|
message_with_fields_factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
|
|
message_with_fields_factory.add_field(FactoryField().assemble("enum_ref", 1, BprotoFieldBaseType.ENUM, 1, "Enum1"))
|
|
message_with_fields_factory.add_field(FactoryField().assemble("bitfield_ref", 2, BprotoFieldBaseType.BITFIELD, 1, "Bitfield2"))
|
|
|
|
factory.add_message(
|
|
message_with_fields_factory.assemble("Message3", 44)
|
|
)
|
|
|
|
factory.add_enum(FactoryEnumeration().assemble("Enum1"))
|
|
factory.add_enum(FactoryEnumeration().assemble("Enum2"))
|
|
factory.add_enum(FactoryEnumeration().assemble("Enum3"))
|
|
|
|
factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
|
|
factory.add_bitfield(FactoryBitfield().assemble("Bitfield2"))
|
|
factory.add_bitfield(FactoryBitfield().assemble("Bitfield3"))
|
|
|
|
protocol = factory.assemble("TESTPROTOCOL", 1)
|
|
|
|
assert protocol.name.name_parts == ["testprotocol"]
|
|
assert isinstance(protocol.name, ComponentName)
|
|
assert protocol.version == 1
|
|
|
|
assert protocol.messages == {
|
|
NameStyleBproto.fromStr("Message1"): factory.messages.get(NameStyleBproto.fromStr("Message1")),
|
|
NameStyleBproto.fromStr("Message2"): factory.messages.get(NameStyleBproto.fromStr("Message2")),
|
|
NameStyleBproto.fromStr("Message3"): factory.messages.get(NameStyleBproto.fromStr("Message3"))
|
|
}
|
|
|
|
assert protocol.enums == {
|
|
NameStyleBproto.fromStr("Enum1"): factory.enums.get(NameStyleBproto.fromStr("Enum1")),
|
|
NameStyleBproto.fromStr("Enum2"): factory.enums.get(NameStyleBproto.fromStr("Enum2")),
|
|
NameStyleBproto.fromStr("Enum3"): factory.enums.get(NameStyleBproto.fromStr("Enum3"))
|
|
}
|
|
|
|
assert protocol.bitfields == {
|
|
NameStyleBproto.fromStr("Bitfield1"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield1")),
|
|
NameStyleBproto.fromStr("Bitfield2"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield2")),
|
|
NameStyleBproto.fromStr("Bitfield3"): factory.bitfields.get(NameStyleBproto.fromStr("Bitfield3"))
|
|
}
|
|
|
|
# Check if references are resolved works
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message3")).fields.get(NameStyleBproto.fromStr("enum_ref")), FieldEnum)
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message3")).fields.get(NameStyleBproto.fromStr("bitfield_ref")), FieldBitfield)
|
|
|
|
|
|
def test_protocol_resolve_refernces():
|
|
enum1 = FactoryEnumeration().assemble("Enum1")
|
|
bitfield1 = FactoryBitfield().assemble("Bitfield1")
|
|
|
|
message1Factory = FactoryMessage()
|
|
message1Factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
|
|
message1Factory.add_field(FactoryField().assemble("enum_field", 1, BprotoFieldBaseType.ENUM, 1, enum1))
|
|
message1Factory.add_field(FactoryField().assemble("enum_ref_field", 2, BprotoFieldBaseType.ENUM, 1, "Enum1"))
|
|
message1Factory.add_field(FactoryField().assemble("bitfield_field", 3, BprotoFieldBaseType.BITFIELD, 1, bitfield1))
|
|
message1Factory.add_field(FactoryField().assemble("bitfield_ref_field", 4, BprotoFieldBaseType.BITFIELD, 1, "Bitfield1"))
|
|
message1 = message1Factory.assemble("Message1", 42)
|
|
|
|
# Check if message is correctly assembled
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("field1")), Field)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("field1")).type == BprotoFieldBaseType.UINT64
|
|
assert message1.fields.get(NameStyleBproto.fromStr("field1")).array_size == 1
|
|
assert message1.fields.get(NameStyleBproto.fromStr("field1")).ref is None
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("field1")).ref, type(None))
|
|
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_field")), FieldEnum)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("enum_field")).type == BprotoFieldBaseType.ENUM
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_field")).enum, Enumeration)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("enum_field")).enum == enum1
|
|
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")), FieldEnumRef)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")).type == BprotoFieldBaseType.ENUM
|
|
assert message1.fields.get(NameStyleBproto.fromStr("enum_ref_field")).ref == "Enum1"
|
|
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_field")), FieldBitfield)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).type == BprotoFieldBaseType.BITFIELD
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield, Bitfield)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield == bitfield1
|
|
|
|
assert isinstance(message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")), FieldBitfieldRef)
|
|
assert message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).type == BprotoFieldBaseType.BITFIELD
|
|
assert message1.fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).ref == "Bitfield1"
|
|
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_message(message1)
|
|
factory.add_enum(enum1)
|
|
factory.add_bitfield(bitfield1)
|
|
protocol = factory.assemble("TestProtocol", 1)
|
|
|
|
# Check if references are resolved works
|
|
|
|
resolver = ProtocolReferenceResolver(protocol)
|
|
resolver.resolve_refrence_protocol()
|
|
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")).type == BprotoFieldBaseType.ENUM
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")), FieldEnum)
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_field")).enum == enum1
|
|
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")).type == BprotoFieldBaseType.ENUM
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")), FieldEnum)
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("enum_ref_field")).enum == enum1
|
|
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")).type == BprotoFieldBaseType.BITFIELD
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")), FieldBitfield)
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_field")).bitfield == bitfield1
|
|
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).type == BprotoFieldBaseType.BITFIELD
|
|
assert isinstance(protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")), FieldBitfield)
|
|
assert protocol.messages.get(NameStyleBproto.fromStr("Message1")).fields.get(NameStyleBproto.fromStr("bitfield_ref_field")).bitfield == bitfield1
|
|
|
|
|
|
def test_protocol_resolve_refernces_unknown_refernces():
|
|
message1Factory = FactoryMessage()
|
|
message1Factory.add_field(FactoryField().assemble("field1", 0, "uint64", 1, None))
|
|
message1Factory.add_field(FactoryField().assemble("enum_ref_field", 1, BprotoFieldBaseType.ENUM, 1, "Enum1"))
|
|
message1Factory.add_field(FactoryField().assemble("bitfield_ref_field", 2, BprotoFieldBaseType.BITFIELD, 1, "Bitfield1",))
|
|
message1 = message1Factory.assemble("Message1", 42)
|
|
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_message(message1)
|
|
|
|
try:
|
|
factory.assemble("TestProtocol", 1)
|
|
assert False
|
|
except Exception as e:
|
|
assert isinstance(e, BprotoUnresolvedReferenceError)
|
|
|
|
try:
|
|
factory.assemble("TestProtocol", 1)
|
|
assert False
|
|
except Exception as e:
|
|
assert isinstance(e, BprotoUnresolvedReferenceError)
|
|
|
|
|
|
def test_protocol_factory_already_define_error():
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_message(FactoryMessage().assemble("Message1", 42))
|
|
try:
|
|
factory.add_message(FactoryMessage().assemble("Message1", 42))
|
|
factory.assemble("A", 1)
|
|
assert False
|
|
except Exception as e:
|
|
assert isinstance(e, BprotoAlreadyDefinedError)
|
|
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_enum(FactoryEnumeration().assemble("Enum1"))
|
|
try:
|
|
factory.assemble("A", 1)
|
|
factory.add_enum(FactoryEnumeration().assemble("Enum1"))
|
|
assert False
|
|
except Exception as e:
|
|
assert isinstance(e, BprotoAlreadyDefinedError)
|
|
|
|
factory = FactoryProtocolDefition()
|
|
factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
|
|
try:
|
|
factory.add_bitfield(FactoryBitfield().assemble("Bitfield1"))
|
|
factory.assemble("A", 1)
|
|
assert False
|
|
except Exception as e:
|
|
assert isinstance(e, BprotoAlreadyDefinedError)
|