def TestAllTypes():
struct = mojom.Struct('test')
array = mojom.Array()
return TestSequence(
(mojom.BOOL, mojom.INT8, mojom.STRING, mojom.UINT8, mojom.INT16,
mojom.DOUBLE, mojom.UINT16, mojom.INT32, mojom.UINT32, mojom.INT64,
mojom.FLOAT, mojom.STRING, mojom.HANDLE, mojom.UINT64,
mojom.Struct('test'), mojom.Array()),
(1, 2, 4, 5, 7, 3, 6, 8, 9, 10, 11, 13, 12, 14, 15, 16, 17),
(0, 1, 2, 4, 6, 8, 16, 24, 28, 32, 40, 44, 48, 56, 64, 72, 80))
def TestBools():
errors = 0
struct = mojom.Struct('test')
struct.AddField('bit0', mojom.BOOL)
struct.AddField('bit1', mojom.BOOL)
struct.AddField('int', mojom.INT32)
struct.AddField('bit2', mojom.BOOL)
struct.AddField('bit3', mojom.BOOL)
struct.AddField('bit4', mojom.BOOL)
struct.AddField('bit5', mojom.BOOL)
struct.AddField('bit6', mojom.BOOL)
struct.AddField('bit7', mojom.BOOL)
struct.AddField('bit8', mojom.BOOL)
ps = pack.PackedStruct(struct)
errors += EXPECT_EQ(10, len(ps.packed_fields))
# First 8 bits packed together.
for i in xrange(8):
pf = ps.packed_fields[i]
errors += EXPECT_EQ(0, pf.offset)
errors += EXPECT_EQ("bit%d" % i, pf.field.name)
errors += EXPECT_EQ(i, pf.bit)
# Ninth bit goes into second byte.
errors += EXPECT_EQ("bit8", ps.packed_fields[8].field.name)
errors += EXPECT_EQ(1, ps.packed_fields[8].offset)
errors += EXPECT_EQ(0, ps.packed_fields[8].bit)
# int comes last.
errors += EXPECT_EQ("int", ps.packed_fields[9].field.name)
errors += EXPECT_EQ(4, ps.packed_fields[9].offset)
return errors
def GetStructFromMethod(method):
"""Converts a method's parameters into the fields of a struct."""
params_class = "%s_%s_Params" % (method.interface.name, method.name)
struct = mojom.Struct(params_class, module=method.interface.module)
for param in method.parameters:
struct.AddField(param.name, param.kind, param.ordinal)
return _GetDataHeader(False, struct)
def StructFromData(module, data):
struct = mojom.Struct(module=module)
struct.name = data['name']
struct.native_only = data['native_only']
struct.spec = 'x:' + module.namespace + '.' + struct.name
module.kinds[struct.spec] = struct
if struct.native_only:
struct.enums = []
struct.constants = []
struct.fields_data = []
else:
struct.enums = map(lambda enum: EnumFromData(module, enum, struct),
data['enums'])
struct.constants = map(
lambda constant: ConstantFromData(module, constant, struct),
data['constants'])
# Stash fields data here temporarily.
struct.fields_data = data['fields']
struct.attributes = data.get('attributes')
# Enforce that a [native=True] attribute is set to make native-only struct
# declarations more explicit.
if struct.native_only:
if not struct.attributes or not struct.attributes.get('native', False):
raise Exception("Native-only struct declarations must include a " +
"native=True attribute.")
return struct
def TestOneField():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT8)
ps = pack.PackedStruct(struct)
errors += EXPECT_EQ(1, len(ps.packed_fields))
return errors
def TestAllTypes():
return TestSequence(
(mojom.BOOL, mojom.INT8, mojom.STRING, mojom.UINT8, mojom.INT16,
mojom.DOUBLE, mojom.UINT16, mojom.INT32, mojom.UINT32, mojom.INT64,
mojom.FLOAT, mojom.STRING, mojom.HANDLE, mojom.UINT64,
mojom.Struct('test'), mojom.Array(), mojom.STRING.MakeNullableKind()),
(1, 2, 4, 5, 7, 3, 6, 8, 9, 10, 11, 13, 12, 14, 15, 16, 17, 18),
(0, 1, 2, 4, 6, 8, 16, 24, 28, 32, 40, 44, 48, 56, 64, 72, 80, 88))
def _GetResponseStructFromMethod(self, method):
"""Converts a method's response_parameters into the fields of a struct."""
params_class = "%s_%s_ResponseParams" % (method.interface.name, method.name)
struct = mojom.Struct(params_class, module=method.interface.module)
for param in method.response_parameters:
struct.AddField(param.name, param.kind, param.ordinal,
attributes=param.attributes)
return self._AddStructComputedData(False, struct)
def GetResponseStructFromMethod(method):
"""Converts a method's response_parameters into the fields of a struct."""
params_class = "%s_%s_ResponseParams" % (method.interface.name, method.name)
struct = mojom.Struct(params_class, module=method.interface.module)
for param in method.response_parameters:
struct.AddField(param.name, param.kind, param.ordinal)
struct.packed = pack.PackedStruct(struct)
return struct
def _GetStructFromMethod(method):
"""Converts a method's parameters into the fields of a struct."""
params_class = "%s_%s_Params" % (method.interface.mojom_name,
method.mojom_name)
struct = mojom.Struct(params_class, module=method.interface.module)
for param in method.parameters:
struct.AddField(param.mojom_name, param.kind, param.ordinal,
attributes=param.attributes)
_AddStructComputedData(False, struct)
return struct
def MethodFromMojom(self, mojom_method, interface):
"""Translates a mojom_types_mojom.MojomMethod to a module.Method.
Args:
mojom_method: {mojom_types_mojom.MojomMethod} to be translated.
interface: {module.Interface} the method is a member of.
Returns:
{module.Method} translated from mojom_method.
"""
method = module.Method(interface, mojom_method.decl_data.short_name)
method.ordinal = mojom_method.ordinal
method.declaration_order = mojom_method.decl_data.declaration_order
method.param_struct = module.Struct()
self.StructFromMojomStruct(method.param_struct,
mojom_method.parameters)
# The name of a synthetic request parameter struct is not guaranteed by
# the frontend to be anything in particular so we set the name of the
# translated struct to a value that the code generators are expecting.
method.param_struct.name = "%s_%s_Params" % (method.interface.name,
method.name)
method.parameters = [
self.ParamFromMojom(param)
for param in mojom_method.parameters.fields
]
if mojom_method.response_params is not None:
method.response_param_struct = module.Struct()
self.StructFromMojomStruct(method.response_param_struct,
mojom_method.response_params)
# The name of a synthetic response parameter struct is not guaranteed by
# the frontend to be anything in particular so we set the name of the
# translated struct to a value that the code generators are expecting.
method.response_param_struct.name = "%s_%s_ResponseParams" % (
method.interface.name, method.name)
method.response_parameters = [
self.ParamFromMojom(param)
for param in mojom_method.response_params.fields
]
method.min_version = mojom_method.min_version
return method
def StructFromData(module, data):
struct = mojom.Struct(module=module)
struct.name = data['name']
struct.attributes = data['attributes']
struct.spec = 'x:' + module.namespace + '.' + struct.name
module.kinds[struct.spec] = struct
struct.enums = map(lambda enum: EnumFromData(module, enum, struct),
data['enums'])
# Stash fields data here temporarily.
struct.fields_data = data['fields']
return struct
def TestOrdinalOrder():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT32, 2)
struct.AddField('testfield2', mojom.INT32, 1)
ps = pack.PackedStruct(struct)
errors += EXPECT_EQ(2, len(ps.packed_fields))
errors += EXPECT_EQ('testfield2', ps.packed_fields[0].field.name)
errors += EXPECT_EQ('testfield1', ps.packed_fields[1].field.name)
return errors
def TestNullableTypes():
kinds = (mojom.STRING.MakeNullableKind(), mojom.HANDLE.MakeNullableKind(),
mojom.Struct('test_struct').MakeNullableKind(),
mojom.DCPIPE.MakeNullableKind(), mojom.Array().MakeNullableKind(),
mojom.DPPIPE.MakeNullableKind(),
mojom.Array(length=5).MakeNullableKind(),
mojom.MSGPIPE.MakeNullableKind(),
mojom.Interface('test_inteface').MakeNullableKind(),
mojom.SHAREDBUFFER.MakeNullableKind(),
mojom.InterfaceRequest().MakeNullableKind())
fields = (1, 2, 4, 3, 5, 6, 8, 7, 9, 10, 11)
offsets = (0, 8, 12, 16, 24, 32, 36, 40, 48, 52, 56)
return TestSequence(kinds, fields, offsets)
def TestSequence(kinds, fields, offsets):
errors = 0
struct = mojom.Struct('test')
index = 1
for kind in kinds:
struct.AddField("%d" % index, kind)
index += 1
ps = pack.PackedStruct(struct)
num_fields = len(ps.packed_fields)
errors += EXPECT_EQ(len(kinds), num_fields)
for i in xrange(num_fields):
EXPECT_EQ("%d" % fields[i], ps.packed_fields[i].field.name)
EXPECT_EQ(offsets[i], ps.packed_fields[i].offset)
return errors
def test_structs(self):
file_name = 'a.mojom'
graph = mojom_files_mojom.MojomFileGraph()
mojom_file = mojom_files_mojom.MojomFile(file_name='a.mojom',
module_namespace='foo.bar')
graph.files = {mojom_file.file_name: mojom_file}
mojom_struct = mojom_types_mojom.MojomStruct(
decl_data=mojom_types_mojom.DeclarationData(
short_name='FirstStruct'))
mojom_struct.fields = [
mojom_types_mojom.StructField(
decl_data=mojom_types_mojom.DeclarationData(
short_name='field01', declared_ordinal=5),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.BOOL)),
mojom_types_mojom.StructField(
decl_data=mojom_types_mojom.DeclarationData(
short_name='field02'),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.DOUBLE),
default_value=mojom_types_mojom.DefaultFieldValue(
value=mojom_types_mojom.Value(
literal_value=mojom_types_mojom.LiteralValue(
double_value=15)))),
]
mojom_struct.decl_data.source_file_info = mojom_types_mojom.SourceFileInfo(
file_name=mojom_file.file_name)
struct = module.Struct()
translator = mojom_translator.FileTranslator(graph, file_name)
translator.StructFromMojom(
struct,
mojom_types_mojom.UserDefinedType(struct_type=mojom_struct))
self.assertEquals('FirstStruct', struct.name)
self.assertEquals(translator._module, struct.module)
self.assertEquals(len(mojom_struct.fields), len(struct.fields))
for gold, f in zip(mojom_struct.fields, struct.fields):
self.assertEquals(f.name, gold.decl_data.short_name)
self.assertEquals(module.BOOL, struct.fields[0].kind)
self.assertEquals(5, struct.fields[0].ordinal)
self.assertEquals(module.DOUBLE, struct.fields[1].kind)
self.assertEquals(None, struct.fields[1].ordinal)
self.assertEquals('15.0', struct.fields[1].default)
def test_imported_struct(self):
graph = mojom_files_mojom.MojomFileGraph()
graph.files = {
'a.mojom':
mojom_files_mojom.MojomFile(file_name='a.mojom',
specified_file_name='',
module_namespace='namespace',
imports=['root/c.mojom']),
'root/c.mojom':
mojom_files_mojom.MojomFile(file_name='root/c.mojom',
specified_file_name='',
module_namespace='otherns',
imports=[]),
}
mojom_struct = mojom_types_mojom.MojomStruct()
mojom_struct.decl_data = mojom_types_mojom.DeclarationData(
short_name='AStruct',
source_file_info=mojom_types_mojom.SourceFileInfo(
file_name='root/c.mojom'))
mojom_struct.fields = []
add_version_info(mojom_struct, 0)
type_key = 'some_type_key'
graph.resolved_types = {
type_key:
mojom_types_mojom.UserDefinedType(struct_type=mojom_struct)
}
struct = module.Struct()
# Translate should create the imports.
translator = mojom_translator.FileTranslator(graph, 'a.mojom')
translator.Translate()
struct = translator.UserDefinedFromTypeRef(
mojom_types_mojom.Type(
type_reference=mojom_types_mojom.TypeReference(
type_key=type_key)))
self.assertEquals(
translator._transitive_imports['root/c.mojom']['module'],
struct.module)
self.assertEquals(translator._transitive_imports['root/c.mojom'],
struct.imported_from)
def _Struct(module, parsed_struct):
"""
Args:
module: {mojom.Module} Module currently being constructed.
parsed_struct: {ast.Struct} Parsed struct.
Returns:
{mojom.Struct} AST struct.
"""
struct = mojom.Struct(module=module)
struct.mojom_name = parsed_struct.mojom_name
struct.native_only = parsed_struct.body is None
struct.spec = 'x:' + module.mojom_namespace + '.' + struct.mojom_name
module.kinds[struct.spec] = struct
if struct.native_only:
struct.enums = []
struct.constants = []
struct.fields_data = []
else:
struct.enums = map(
lambda enum: _Enum(module, enum, struct),
_ElemsOfType(parsed_struct.body, ast.Enum,
parsed_struct.mojom_name))
struct.constants = map(
lambda constant: _Constant(module, constant, struct),
_ElemsOfType(parsed_struct.body, ast.Const,
parsed_struct.mojom_name))
# Stash fields parsed_struct here temporarily.
struct.fields_data = _ElemsOfType(parsed_struct.body, ast.StructField,
parsed_struct.mojom_name)
struct.attributes = _AttributeListToDict(parsed_struct.attribute_list)
# Enforce that a [Native] attribute is set to make native-only struct
# declarations more explicit.
if struct.native_only:
if not struct.attributes or not struct.attributes.get('Native', False):
raise Exception("Native-only struct declarations must include a " +
"Native attribute.")
if struct.attributes and struct.attributes.get('CustomSerializer', False):
struct.custom_serializer = True
return struct
def test_contained_declarations(self):
graph = mojom_files_mojom.MojomFileGraph()
file_name = 'root/f.mojom'
mojom_enum = mojom_types_mojom.MojomEnum(
values=[],
decl_data=mojom_types_mojom.DeclarationData(
short_name='AnEnum',
source_file_info=mojom_types_mojom.SourceFileInfo(
file_name=file_name),
container_type_key='parent_key'))
graph.resolved_types = {
'enum_key': mojom_types_mojom.UserDefinedType(enum_type=mojom_enum)}
mojom_const = mojom_types_mojom.DeclaredConstant(
decl_data=mojom_types_mojom.DeclarationData(
short_name='AConst',
container_type_key='parent_key'),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.INT64),
value=mojom_types_mojom.Value(
literal_value=mojom_types_mojom.LiteralValue(
int64_value=30)))
user_defined_value = mojom_types_mojom.UserDefinedValue()
user_defined_value.declared_constant = mojom_const
graph.resolved_values = {'value_key': user_defined_value}
contained_declarations = mojom_types_mojom.ContainedDeclarations(
enums=['enum_key'], constants=['value_key'])
translator = mojom_translator.FileTranslator(graph, file_name)
struct = module.Struct(name='parent')
translator._type_cache['parent_key'] = struct
translator.PopulateContainedDeclarationsFromMojom(
struct, contained_declarations)
self.assertEquals(
mojom_enum.decl_data.short_name, struct.enums[0].name)
self.assertEquals(struct, struct.enums[0].parent_kind)
self.assertEquals(
mojom_const.decl_data.short_name, struct.constants[0].name)
self.assertEquals(struct, struct.constants[0].parent_kind)
def TestPaddingPackedOutOfOrderByOrdinal():
errors = 0
struct = mojom.Struct('test')
struct.AddField('testfield1', mojom.INT8)
struct.AddField('testfield3', mojom.UINT8, 3)
struct.AddField('testfield2', mojom.INT32, 2)
ps = pack.PackedStruct(struct)
errors += EXPECT_EQ(3, len(ps.packed_fields))
# Second byte should be packed in behind first, altering order.
errors += EXPECT_EQ('testfield1', ps.packed_fields[0].field.name)
errors += EXPECT_EQ('testfield3', ps.packed_fields[1].field.name)
errors += EXPECT_EQ('testfield2', ps.packed_fields[2].field.name)
# Second byte should be packed with first.
errors += EXPECT_EQ(0, ps.packed_fields[0].offset)
errors += EXPECT_EQ(1, ps.packed_fields[1].offset)
errors += EXPECT_EQ(4, ps.packed_fields[2].offset)
return errors
def test_structs(self):
file_name = 'a.mojom'
graph = mojom_files_mojom.MojomFileGraph()
mojom_file = mojom_files_mojom.MojomFile(file_name='a.mojom',
module_namespace='foo.bar')
graph.files = {mojom_file.file_name: mojom_file}
mojom_struct = mojom_types_mojom.MojomStruct(
decl_data=mojom_types_mojom.DeclarationData(
short_name='FirstStruct'))
mojom_struct.fields = [
mojom_types_mojom.StructField(
decl_data=mojom_types_mojom.DeclarationData(
short_name='field03', declaration_order=2),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.BOOL),
offset=21,
bit=6,
min_version=11),
mojom_types_mojom.StructField(
decl_data=mojom_types_mojom.DeclarationData(
short_name='field01',
declared_ordinal=1,
declaration_order=0),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.BOOL),
offset=17,
bit=1,
min_version=4),
mojom_types_mojom.StructField(
decl_data=mojom_types_mojom.DeclarationData(
short_name='field02', declaration_order=1),
type=mojom_types_mojom.Type(
simple_type=mojom_types_mojom.SimpleType.DOUBLE),
offset=0,
bit=0,
min_version=0,
default_value=mojom_types_mojom.DefaultFieldValue(
value=mojom_types_mojom.Value(
literal_value=mojom_types_mojom.LiteralValue(
double_value=15)))),
]
mojom_struct.version_info = [
mojom_types_mojom.StructVersion(version_number=0,
num_bytes=67,
num_fields=1),
mojom_types_mojom.StructVersion(version_number=1,
num_bytes=76,
num_fields=3),
]
# mojom_fields_declaration_order lists, in declaration order, the indices
# of the fields in mojom_types_mojom.StructField.
mojom_fields_declaration_order = [1, 2, 0]
mojom_struct.decl_data.source_file_info = mojom_types_mojom.SourceFileInfo(
file_name=mojom_file.file_name)
struct = module.Struct()
translator = mojom_translator.FileTranslator(graph, file_name)
translator.StructFromMojom(
struct,
mojom_types_mojom.UserDefinedType(struct_type=mojom_struct))
self.assertEquals('FirstStruct', struct.name)
self.assertEquals(translator._module, struct.module)
self.assertEquals(len(mojom_struct.fields), len(struct.fields))
for index, gold_index in enumerate(mojom_fields_declaration_order):
gold = mojom_struct.fields[gold_index]
f = struct.fields[index]
self.assertEquals(f.name, gold.decl_data.short_name)
if gold.decl_data.declared_ordinal >= 0:
self.assertEquals(gold.decl_data.declared_ordinal, f.ordinal)
else:
self.assertEquals(None, f.ordinal)
self.assertEquals(gold_index, f.computed_ordinal)
self.assertEquals(gold.offset, f.computed_offset)
self.assertEquals(gold.bit, f.computed_bit)
self.assertEquals(gold.min_version, f.computed_min_version)
self.assertEquals(struct.fields_in_ordinal_order[index].name,
mojom_struct.fields[index].decl_data.short_name)
self.assertEquals(2, len(struct.versions))
for i in xrange(0, 2):
self.assertEquals(mojom_struct.version_info[i].version_number,
struct.versions[i].version)
self.assertEquals(mojom_struct.version_info[i].num_bytes,
struct.versions[i].num_bytes)
self.assertEquals(mojom_struct.version_info[i].num_fields,
struct.versions[i].num_fields)
self.assertEquals(module.BOOL, struct.fields[0].kind)
self.assertEquals(module.DOUBLE, struct.fields[1].kind)
self.assertEquals('15.0', struct.fields[1].default)
def TestZeroFields():
errors = 0
struct = mojom.Struct('test')
ps = pack.PackedStruct(struct)
errors += EXPECT_EQ(0, len(ps.packed_fields))
return errors
