def test_child_enum(self):
        file_name = 'a.mojom'
        mojom_enum = fidl_types_fidl.FidlEnum()
        mojom_enum.decl_data = fidl_types_fidl.DeclarationData(
            short_name='AnEnum',
            source_file_info=fidl_types_fidl.SourceFileInfo(
                file_name=file_name),
            container_type_key='struct_key')
        mojom_enum.values = []

        graph = fidl_files_fidl.FidlFileGraph()
        mojom_struct = fidl_types_fidl.FidlStruct(
            fields=[],
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AStruct',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        add_version_info(mojom_struct, 0)
        graph.resolved_types = {
            'struct_key':
            fidl_types_fidl.UserDefinedType(struct_type=mojom_struct)
        }

        enum = module.Enum()
        translator = mojom_translator.FileTranslator(graph, file_name)
        translator.EnumFromMojom(
            enum, fidl_types_fidl.UserDefinedType(enum_type=mojom_enum))

        self.assertEquals(mojom_enum.decl_data.short_name, enum.name)
        self.assertEquals(len(mojom_enum.values), len(enum.fields))
    def test_constant(self):
        file_name = 'a.mojom'
        graph = fidl_files_fidl.FidlFileGraph()

        mojom_const = fidl_types_fidl.DeclaredConstant()
        mojom_const.decl_data = fidl_types_fidl.DeclarationData(
            short_name='foo', container_type_key='struct_key')
        mojom_const.type = fidl_types_fidl.Type(
            simple_type=fidl_types_fidl.SimpleType.INT64)
        mojom_const.value = fidl_types_fidl.Value()
        mojom_const.value.literal_value = fidl_types_fidl.LiteralValue(
            int64_value=20)

        mojom_struct = fidl_types_fidl.FidlStruct(
            fields=[],
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AStruct',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        add_version_info(mojom_struct, 0)
        graph.resolved_types = {
            'struct_key':
            fidl_types_fidl.UserDefinedType(struct_type=mojom_struct)
        }

        const = module.Constant()
        translator = mojom_translator.FileTranslator(graph, file_name)
        translator.ConstantFromMojom(const, mojom_const)

        self.assertEquals(mojom_const.decl_data.short_name, const.name)
        self.assertEquals(module.INT64, const.kind)
        self.assertEquals('20', const.value)
        self.assertEquals(translator.UserDefinedFromTypeKey('struct_key'),
                          const.parent_kind)
    def test_imported_struct(self):
        graph = fidl_files_fidl.FidlFileGraph()

        graph.files = {
            'a.mojom':
            fidl_files_fidl.FidlFile(file_name='a.mojom',
                                     specified_file_name='',
                                     module_namespace='namespace',
                                     imports=['root/c.mojom']),
            'root/c.mojom':
            fidl_files_fidl.FidlFile(file_name='root/c.mojom',
                                     specified_file_name='',
                                     module_namespace='otherns',
                                     imports=[]),
        }

        mojom_struct = fidl_types_fidl.FidlStruct()
        mojom_struct.decl_data = fidl_types_fidl.DeclarationData(
            short_name='AStruct',
            source_file_info=fidl_types_fidl.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: fidl_types_fidl.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(
            fidl_types_fidl.Type(type_reference=fidl_types_fidl.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 test_user_defined_type_type(self):
        graph = fidl_files_fidl.FidlFileGraph()
        mojom_struct = fidl_types_fidl.FidlStruct(
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='FirstStruct'))
        type_key = 'some opaque string'
        mojom_struct.fields = [
            # Make sure recursive structs are correctly handled.
            fidl_types_fidl.StructField(
                decl_data=fidl_types_fidl.DeclarationData(
                    short_name='field00'),
                type=fidl_types_fidl.Type(
                    type_reference=fidl_types_fidl.TypeReference(
                        type_key=type_key)))
        ]
        add_version_info(mojom_struct, 1)
        graph.resolved_types = {
            type_key: fidl_types_fidl.UserDefinedType(struct_type=mojom_struct)
        }

        mojom_type = fidl_types_fidl.Type()
        mojom_type.type_reference = fidl_types_fidl.TypeReference(
            type_key=type_key)

        t = mojom_translator.FileTranslator(graph, None)
        result = t.KindFromMojom(mojom_type)
        self.assertTrue(module.IsStructKind(result))
        self.assertEquals(mojom_struct.decl_data.short_name, result.name)
        self.assertEquals(result, result.fields[0].kind)
        self.assertEquals(type_key, result.type_key)

        # Make sure we create only one module object per type.
        result2 = t.KindFromMojom(mojom_type)
        self.assertIs(result, result2)

        # Nullable type reference
        mojom_type.type_reference.nullable = True
        nullable_result = t.KindFromMojom(mojom_type)
        self.assertTrue(module.IsNullableKind(nullable_result))
    def test_method(self):
        file_name = 'a.mojom'
        mojom_method = fidl_types_fidl.FidlMethod(
            ordinal=10,
            min_version=6,
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AMethod',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))

        param1 = fidl_types_fidl.StructField(
            decl_data=fidl_types_fidl.DeclarationData(short_name='a_param'),
            type=fidl_types_fidl.Type(
                simple_type=fidl_types_fidl.SimpleType.UINT32),
            offset=21,
            bit=6,
            min_version=11)
        param2 = fidl_types_fidl.StructField(
            decl_data=fidl_types_fidl.DeclarationData(short_name='b_param'),
            type=fidl_types_fidl.Type(
                simple_type=fidl_types_fidl.SimpleType.UINT64),
            offset=22,
            bit=7,
            min_version=12)
        mojom_method.parameters = fidl_types_fidl.FidlStruct(
            fields=[param1, param2],
            version_info=build_version_info(2),
            decl_data=build_decl_data('Not used'))

        interface = module.Interface('MyInterface')
        graph = fidl_files_fidl.FidlFileGraph()
        translator = mojom_translator.FileTranslator(graph, file_name)
        method = translator.MethodFromMojom(mojom_method, interface)

        self.assertEquals(mojom_method.decl_data.short_name, method.name)
        self.assertEquals(interface, method.interface)
        self.assertEquals(mojom_method.ordinal, method.ordinal)
        self.assertEquals(mojom_method.min_version, method.min_version)
        self.assertIsNone(method.response_parameters)
        self.assertEquals(len(mojom_method.parameters.fields),
                          len(method.parameters))
        self.assertEquals(param1.decl_data.short_name,
                          method.parameters[0].name)
        self.assertEquals(param2.decl_data.short_name,
                          method.parameters[1].name)
        self.assertEquals('MyInterface_AMethod_Params',
                          method.param_struct.name)
        self.assertEquals(len(mojom_method.parameters.fields),
                          len(method.param_struct.fields))
        for i in xrange(0, len(mojom_method.parameters.fields)):
            gold = mojom_method.parameters.fields[i]
            f = method.param_struct.fields_in_ordinal_order[i]
            self.assertEquals(gold.decl_data.short_name, f.name)
            self.assertEquals(gold.offset, f.computed_offset)
            self.assertEquals(gold.bit, f.computed_bit)
            self.assertEquals(gold.min_version, f.computed_min_version)

        # Add empty return params.
        mojom_method.response_params = fidl_types_fidl.FidlStruct(fields=[])
        add_version_info(mojom_method.response_params, 0)
        add_decl_data(mojom_method.response_params, 'AMethod_Response')
        method = translator.MethodFromMojom(mojom_method, interface)
        self.assertEquals([], method.response_parameters)

        # Add non-empty return params.
        mojom_method.response_params.fields = [param1]
        method = translator.MethodFromMojom(mojom_method, interface)
        self.assertEquals(param1.decl_data.short_name,
                          method.response_parameters[0].name)
    def do_interface_test(self, specify_service_name):
        file_name = 'a.mojom'
        mojom_interface = fidl_types_fidl.FidlInterface(
            current_version=47,
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AnInterface',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        if specify_service_name:
            mojom_interface.service_name = 'test::TheInterface'
            mojom_interface.decl_data.attributes = [
                fidl_types_fidl.Attribute(
                    key='ServiceName',
                    value=fidl_types_fidl.LiteralValue(
                        string_value='test::TheInterface'))
            ]
        else:
            mojom_interface.service_name = None
        mojom_method10 = fidl_types_fidl.FidlMethod(
            ordinal=10,
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AMethod10',
                declaration_order=1,
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)),
            parameters=fidl_types_fidl.FidlStruct(
                fields=[],
                version_info=build_version_info(0),
                decl_data=build_decl_data('AMethod10_Request')))
        mojom_method0 = fidl_types_fidl.FidlMethod(
            ordinal=0,
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AMethod0',
                declaration_order=1,
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)),
            parameters=fidl_types_fidl.FidlStruct(
                fields=[],
                version_info=build_version_info(0),
                decl_data=build_decl_data('AMethod0_Request')))
        mojom_method7 = fidl_types_fidl.FidlMethod(
            ordinal=7,
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AMethod7',
                declaration_order=0,
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)),
            parameters=fidl_types_fidl.FidlStruct(
                fields=[],
                version_info=build_version_info(0),
                decl_data=build_decl_data('AMethod7_Request')))
        mojom_interface.methods = {
            10: mojom_method10,
            0: mojom_method0,
            7: mojom_method7
        }

        interface = module.Interface()
        graph = fidl_files_fidl.FidlFileGraph()
        translator = mojom_translator.FileTranslator(graph, file_name)
        translator.InterfaceFromMojom(
            interface,
            fidl_types_fidl.UserDefinedType(interface_type=mojom_interface))

        self.assertEquals(translator._module, interface.module)
        self.assertEquals('AnInterface', interface.name)
        self.assertEquals(mojom_interface.current_version, interface.version)
        # The methods should be ordered by declaration_order.
        self.assertEquals(7, interface.methods[0].ordinal)
        self.assertEquals(0, interface.methods[1].ordinal)
        self.assertEquals(10, interface.methods[2].ordinal)
        if specify_service_name:
            self.assertEquals('test::TheInterface', interface.service_name)
        else:
            self.assertEquals(None, interface.service_name)
    def test_basics(self):
        graph = fidl_files_fidl.FidlFileGraph(resolved_types={})

        file_name = 'root/f.mojom'
        imported_file_name = 'other/a.mojom'
        second_level_imported_file_name = 'something/other.mojom'
        mojom_file = fidl_files_fidl.FidlFile(
            file_name=file_name,
            specified_file_name='specified_file_name',
            module_namespace='somens',
            imports=[imported_file_name])
        imported_file = fidl_files_fidl.FidlFile(
            file_name=imported_file_name,
            specified_file_name='',
            module_namespace='somens',
            imports=[second_level_imported_file_name])
        second_level_imported_file = fidl_files_fidl.FidlFile(
            file_name=second_level_imported_file_name,
            specified_file_name='',
            module_namespace='somens')
        graph.files = {
            file_name: mojom_file,
            imported_file_name: imported_file,
            second_level_imported_file_name: second_level_imported_file
        }

        mojom_interface = fidl_types_fidl.FidlInterface(
            methods={},
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AnInterface',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        graph.resolved_types[
            'interface_key'] = fidl_types_fidl.UserDefinedType(
                interface_type=mojom_interface)

        mojom_struct = fidl_types_fidl.FidlStruct(
            fields=[],
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AStruct',
                full_identifier='foo.AStruct',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        add_version_info(mojom_struct, 0)
        graph.resolved_types['struct_key'] = fidl_types_fidl.UserDefinedType(
            struct_type=mojom_struct)

        mojom_union = fidl_types_fidl.FidlUnion(
            fields=[],
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AUnion',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        graph.resolved_types['union_key'] = fidl_types_fidl.UserDefinedType(
            union_type=mojom_union)

        mojom_enum = fidl_types_fidl.FidlEnum(
            values=[],
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='AnEnum',
                source_file_info=fidl_types_fidl.SourceFileInfo(
                    file_name=file_name)))
        graph.resolved_types['enum_key'] = fidl_types_fidl.UserDefinedType(
            enum_type=mojom_enum)

        mojom_const = fidl_types_fidl.DeclaredConstant(
            decl_data=fidl_types_fidl.DeclarationData(short_name='AConst'),
            type=fidl_types_fidl.Type(
                simple_type=fidl_types_fidl.SimpleType.INT64),
            value=fidl_types_fidl.Value(
                literal_value=fidl_types_fidl.LiteralValue(int64_value=30)))
        graph.resolved_constants = {'constant_key': mojom_const}

        mojom_file.declared_fidl_objects = fidl_files_fidl.KeysByType(
            interfaces=['interface_key'],
            structs=['struct_key'],
            unions=['union_key'],
            top_level_enums=['enum_key'],
            top_level_constants=['constant_key'])

        mod = mojom_translator.FileTranslator(graph, file_name).Translate()

        self.assertEquals('f.mojom', mod.name)
        self.assertEquals(mojom_file.specified_file_name, mod.specified_name)
        self.assertEquals(mojom_file.file_name, mod.path)
        self.assertEquals(mojom_file.module_namespace, mod.namespace)

        self.assertEquals(1, len(mod.imports))
        self.assertEquals('a.mojom', mod.imports[0]['module_name'])
        self.assertEquals(imported_file.module_namespace,
                          mod.imports[0]['namespace'])
        self.assertEquals(imported_file.file_name,
                          mod.imports[0]['module'].path)

        self.assertEquals(2, len(mod.transitive_imports))
        transitive_imports_paths = [
            imp['module'].path for imp in mod.transitive_imports
        ]
        self.assertIn(imported_file_name, transitive_imports_paths)
        self.assertIn(second_level_imported_file_name,
                      transitive_imports_paths)

        self.assertEquals('AnInterface', mod.interfaces[0].name)
        # Interfaces should be assigned their name as their spec.
        self.assertEquals('AnInterface', mod.interfaces[0].spec)
        self.assertEquals(mojom_struct.decl_data.short_name,
                          mod.structs[0].name)
        # The struct was given a full_identifier so its spec should be that.
        self.assertEquals(mojom_struct.decl_data.full_identifier,
                          mod.structs[0].spec)
        self.assertEquals(mojom_union.decl_data.short_name, mod.unions[0].name)
        # The union was given a short name but not a full_identifier so its spec
        # should be the short name.
        self.assertEquals(mojom_union.decl_data.short_name, mod.unions[0].spec)
        self.assertEquals(mojom_enum.decl_data.short_name, mod.enums[0].name)
        self.assertEquals(mojom_const.decl_data.short_name,
                          mod.constants[0].name)

        imported_mod = mojom_translator.FileTranslator(
            graph, imported_file_name).Translate()
        self.assertFalse(imported_mod.specified_name)
    def test_structs(self):
        file_name = 'a.mojom'
        graph = fidl_files_fidl.FidlFileGraph()
        mojom_file = fidl_files_fidl.FidlFile(file_name='a.mojom',
                                              module_namespace='foo.bar')
        graph.files = {mojom_file.file_name: mojom_file}

        mojom_struct = fidl_types_fidl.FidlStruct(
            decl_data=fidl_types_fidl.DeclarationData(
                short_name='FirstStruct'))
        mojom_struct.fields = [
            fidl_types_fidl.StructField(
                decl_data=fidl_types_fidl.DeclarationData(short_name='field03',
                                                          declaration_order=2),
                type=fidl_types_fidl.Type(
                    simple_type=fidl_types_fidl.SimpleType.BOOL),
                offset=21,
                bit=6,
                min_version=11),
            fidl_types_fidl.StructField(
                decl_data=fidl_types_fidl.DeclarationData(short_name='field01',
                                                          declared_ordinal=1,
                                                          declaration_order=0),
                type=fidl_types_fidl.Type(
                    simple_type=fidl_types_fidl.SimpleType.BOOL),
                offset=17,
                bit=1,
                min_version=4),
            fidl_types_fidl.StructField(
                decl_data=fidl_types_fidl.DeclarationData(short_name='field02',
                                                          declaration_order=1),
                type=fidl_types_fidl.Type(
                    simple_type=fidl_types_fidl.SimpleType.DOUBLE),
                offset=0,
                bit=0,
                min_version=0,
                default_value=fidl_types_fidl.DefaultFieldValue(
                    value=fidl_types_fidl.Value(
                        literal_value=fidl_types_fidl.LiteralValue(
                            double_value=15)))),
        ]
        mojom_struct.version_info = [
            fidl_types_fidl.StructVersion(version_number=0,
                                          num_bytes=67,
                                          num_fields=1),
            fidl_types_fidl.StructVersion(version_number=1,
                                          num_bytes=76,
                                          num_fields=3),
        ]
        # mojom_fields_declaration_order lists, in declaration order, the indices
        # of the fields in fidl_types_fidl.StructField.
        mojom_fields_declaration_order = [1, 2, 0]
        mojom_struct.decl_data.source_file_info = fidl_types_fidl.SourceFileInfo(
            file_name=mojom_file.file_name)

        struct = module.Struct()
        translator = mojom_translator.FileTranslator(graph, file_name)
        translator.StructFromMojom(
            struct, fidl_types_fidl.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)