| # Copyright 2014 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import imp |
| import os.path |
| import sys |
| import unittest |
| |
| def _GetDirAbove(dirname): |
| """Returns the directory "above" this file containing |dirname| (which must |
| also be "above" this file).""" |
| path = os.path.abspath(__file__) |
| while True: |
| path, tail = os.path.split(path) |
| assert tail |
| if tail == dirname: |
| return path |
| |
| try: |
| imp.find_module("mojom") |
| except ImportError: |
| sys.path.append(os.path.join(_GetDirAbove("pylib"), "pylib")) |
| from mojom.generate import data |
| from mojom.generate import module as mojom |
| |
| |
| class DataTest(unittest.TestCase): |
| |
| def testStructDataConversion(self): |
| """Tests that a struct can be converted from data.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| struct_data = { |
| 'name': 'SomeStruct', |
| 'enums': [], |
| 'constants': [], |
| 'fields': [ |
| {'name': 'field1', 'kind': 'i32'}, |
| {'name': 'field2', 'kind': 'i32', 'ordinal': 10}, |
| {'name': 'field3', 'kind': 'i32', 'default': 15}]} |
| |
| struct = data.StructFromData(module, struct_data) |
| struct.fields = map(lambda field: |
| data.StructFieldFromData(module, field, struct), struct.fields_data) |
| self.assertEquals(struct_data, data.StructToData(struct)) |
| |
| def testUnionDataConversion(self): |
| """Tests that a union can be converted from data.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| union_data = { |
| 'name': 'SomeUnion', |
| 'fields': [ |
| {'name': 'field1', 'kind': 'i32'}, |
| {'name': 'field2', 'kind': 'i32', 'ordinal': 10}]} |
| |
| union = data.UnionFromData(module, union_data) |
| union.fields = map(lambda field: |
| data.UnionFieldFromData(module, field, union), union.fields_data) |
| self.assertEquals(union_data, data.UnionToData(union)) |
| |
| def testImportFromDataNoMissingImports(self): |
| """Tests that unions, structs, interfaces and enums are imported.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| imported_module = mojom.Module('import_module', 'import_namespace') |
| #TODO(azani): Init values in module.py. |
| #TODO(azani): Test that values are imported. |
| imported_module.values = {} |
| imported_data = {'module' : imported_module} |
| |
| |
| struct = mojom.Struct('TestStruct', module=module) |
| imported_module.kinds[struct.spec] = struct |
| |
| union = mojom.Union('TestUnion', module=module) |
| imported_module.kinds[union.spec] = union |
| |
| interface = mojom.Interface('TestInterface', module=module) |
| imported_module.kinds[interface.spec] = interface |
| |
| enum = mojom.Enum('TestEnum', module=module) |
| imported_module.kinds[enum.spec] = enum |
| |
| data.ImportFromData(module, imported_data) |
| |
| # Test that the kind was imported. |
| self.assertIn(struct.spec, module.kinds) |
| self.assertEquals(struct.name, module.kinds[struct.spec].name) |
| |
| self.assertIn(union.spec, module.kinds) |
| self.assertEquals(union.name, module.kinds[union.spec].name) |
| |
| self.assertIn(interface.spec, module.kinds) |
| self.assertEquals(interface.name, module.kinds[interface.spec].name) |
| |
| self.assertIn(enum.spec, module.kinds) |
| self.assertEquals(enum.name, module.kinds[enum.spec].name) |
| |
| # Test that the imported kind is a copy and not the original. |
| self.assertIsNot(struct, module.kinds[struct.spec]) |
| self.assertIsNot(union, module.kinds[union.spec]) |
| self.assertIsNot(interface, module.kinds[interface.spec]) |
| self.assertIsNot(enum, module.kinds[enum.spec]) |
| |
| def testImportFromDataNoExtraneousImports(self): |
| """Tests that arrays, maps and interface requests are not imported.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| imported_module = mojom.Module('import_module', 'import_namespace') |
| #TODO(azani): Init values in module.py. |
| imported_module.values = {} |
| imported_data = {'module' : imported_module} |
| |
| array = mojom.Array(mojom.INT16, length=20) |
| imported_module.kinds[array.spec] = array |
| |
| map_kind = mojom.Map(mojom.INT16, mojom.INT16) |
| imported_module.kinds[map_kind.spec] = map_kind |
| |
| interface = mojom.Interface('TestInterface', module=module) |
| imported_module.kinds[interface.spec] = interface |
| |
| interface_req = mojom.InterfaceRequest(interface) |
| imported_module.kinds[interface_req.spec] = interface_req |
| |
| data.ImportFromData(module, imported_data) |
| |
| self.assertNotIn(array.spec, module.kinds) |
| self.assertNotIn(map_kind.spec, module.kinds) |
| self.assertNotIn(interface_req.spec, module.kinds) |
| |
| def testNonInterfaceAsInterfaceRequest(self): |
| """Tests that a non-interface cannot be used for interface requests.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| interface = mojom.Interface('TestInterface', module=module) |
| method_dict = { |
| 'name': 'Foo', |
| 'parameters': [{'name': 'foo', 'kind': 'r:i32'}], |
| } |
| with self.assertRaises(Exception) as e: |
| data.MethodFromData(module, method_dict, interface) |
| self.assertEquals(e.exception.__str__(), |
| 'Interface request requires \'i32\' to be an interface.') |
| |
| def testNonInterfaceAsAssociatedInterface(self): |
| """Tests that a non-interface type cannot be used for associated |
| interfaces.""" |
| module = mojom.Module('test_module', 'test_namespace') |
| interface = mojom.Interface('TestInterface', module=module) |
| method_dict = { |
| 'name': 'Foo', |
| 'parameters': [{'name': 'foo', 'kind': 'asso:i32'}], |
| } |
| with self.assertRaises(Exception) as e: |
| data.MethodFromData(module, method_dict, interface) |
| self.assertEquals( |
| e.exception.__str__(), |
| 'Associated interface requires \'i32\' to be an interface.') |