| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 import unittest | |
| 6 import module | |
| 7 | |
| 8 try: | |
| 9 import mojom_translator | |
| 10 from generated import mojom_files_mojom | |
| 11 from generated import mojom_types_mojom | |
| 12 bindings_imported = True | |
| 13 except ImportError: | |
| 14 bindings_imported = False | |
| 15 | |
| 16 | |
| 17 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 18 class TranslateFileGraph(unittest.TestCase): | |
| 19 | |
| 20 def test_basics(self): | |
| 21 g = mojom_files_mojom.MojomFileGraph() | |
| 22 | |
| 23 # File names need to be set so the file can be translated at all. | |
| 24 g.files = { | |
| 25 'a.mojom': mojom_files_mojom.MojomFile( | |
| 26 file_name='a.mojom', | |
| 27 specified_file_name='', | |
| 28 imports=[]), | |
| 29 'b.mojom': mojom_files_mojom.MojomFile( | |
| 30 file_name='b.mojom', | |
| 31 specified_file_name='', | |
| 32 imports=[]), | |
| 33 'root/c.mojom': mojom_files_mojom.MojomFile( | |
| 34 file_name='root/c.mojom', | |
| 35 specified_file_name='', | |
| 36 imports=[]), | |
| 37 } | |
| 38 | |
| 39 modules = mojom_translator.TranslateFileGraph(g) | |
| 40 self.assertEquals(len(modules), len(g.files)) | |
| 41 | |
| 42 | |
| 43 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 44 class TestTranslateFile(unittest.TestCase): | |
| 45 | |
| 46 def test_basics(self): | |
| 47 graph = mojom_files_mojom.MojomFileGraph( | |
| 48 resolved_types={}) | |
| 49 | |
| 50 file_name = 'root/f.mojom' | |
| 51 imported_file_name = 'other/a.mojom' | |
| 52 second_level_imported_file_name = 'something/other.mojom' | |
| 53 mojom_file = mojom_files_mojom.MojomFile( | |
| 54 file_name=file_name, | |
| 55 specified_file_name='specified_file_name', | |
| 56 module_namespace='somens', | |
| 57 imports=[imported_file_name]) | |
| 58 imported_file = mojom_files_mojom.MojomFile( | |
| 59 file_name=imported_file_name, | |
| 60 specified_file_name='', | |
| 61 module_namespace='somens', | |
| 62 imports=[second_level_imported_file_name]) | |
| 63 second_level_imported_file = mojom_files_mojom.MojomFile( | |
| 64 file_name=second_level_imported_file_name, | |
| 65 specified_file_name='', | |
| 66 module_namespace='somens') | |
| 67 graph.files = { | |
| 68 file_name: mojom_file, | |
| 69 imported_file_name: imported_file, | |
| 70 second_level_imported_file_name: second_level_imported_file | |
| 71 } | |
| 72 | |
| 73 mojom_interface = mojom_types_mojom.MojomInterface( | |
| 74 methods={}, | |
| 75 decl_data=mojom_types_mojom.DeclarationData( | |
| 76 short_name='AnInterface', | |
| 77 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 78 file_name=file_name))) | |
| 79 graph.resolved_types['interface_key'] = mojom_types_mojom.UserDefinedType( | |
| 80 interface_type=mojom_interface) | |
| 81 | |
| 82 mojom_struct = mojom_types_mojom.MojomStruct( | |
| 83 fields=[], | |
| 84 decl_data=mojom_types_mojom.DeclarationData( | |
| 85 short_name='AStruct', | |
| 86 full_identifier='foo.AStruct', | |
| 87 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 88 file_name=file_name))) | |
| 89 add_version_info(mojom_struct, 0) | |
| 90 graph.resolved_types['struct_key'] = mojom_types_mojom.UserDefinedType( | |
| 91 struct_type=mojom_struct) | |
| 92 | |
| 93 mojom_union = mojom_types_mojom.MojomUnion( | |
| 94 fields=[], | |
| 95 decl_data=mojom_types_mojom.DeclarationData( | |
| 96 short_name='AUnion', | |
| 97 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 98 file_name=file_name))) | |
| 99 graph.resolved_types['union_key'] = mojom_types_mojom.UserDefinedType( | |
| 100 union_type=mojom_union) | |
| 101 | |
| 102 mojom_enum = mojom_types_mojom.MojomEnum( | |
| 103 values=[], | |
| 104 decl_data=mojom_types_mojom.DeclarationData( | |
| 105 short_name='AnEnum', | |
| 106 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 107 file_name=file_name))) | |
| 108 graph.resolved_types['enum_key'] = mojom_types_mojom.UserDefinedType( | |
| 109 enum_type=mojom_enum) | |
| 110 | |
| 111 mojom_const = mojom_types_mojom.DeclaredConstant( | |
| 112 decl_data=mojom_types_mojom.DeclarationData(short_name='AConst'), | |
| 113 type=mojom_types_mojom.Type( | |
| 114 simple_type=mojom_types_mojom.SimpleType.INT64), | |
| 115 value=mojom_types_mojom.Value( | |
| 116 literal_value=mojom_types_mojom.LiteralValue( | |
| 117 int64_value=30))) | |
| 118 graph.resolved_constants = {'constant_key': mojom_const} | |
| 119 | |
| 120 mojom_file.declared_mojom_objects = mojom_files_mojom.KeysByType( | |
| 121 interfaces=['interface_key'], | |
| 122 structs=['struct_key'], | |
| 123 unions=['union_key'], | |
| 124 top_level_enums=['enum_key'], | |
| 125 top_level_constants=['constant_key'] | |
| 126 ) | |
| 127 | |
| 128 mod = mojom_translator.FileTranslator(graph, file_name).Translate() | |
| 129 | |
| 130 self.assertEquals('f.mojom', mod.name) | |
| 131 self.assertEquals(mojom_file.specified_file_name, mod.specified_name) | |
| 132 self.assertEquals(mojom_file.file_name, mod.path) | |
| 133 self.assertEquals(mojom_file.module_namespace, mod.namespace) | |
| 134 | |
| 135 self.assertEquals(1, len(mod.imports)) | |
| 136 self.assertEquals('a.mojom', mod.imports[0]['module_name']) | |
| 137 self.assertEquals(imported_file.module_namespace, | |
| 138 mod.imports[0]['namespace']) | |
| 139 self.assertEquals(imported_file.file_name, mod.imports[0]['module'].path) | |
| 140 | |
| 141 self.assertEquals(2, len(mod.transitive_imports)) | |
| 142 transitive_imports_paths = [imp['module'].path | |
| 143 for imp in mod.transitive_imports] | |
| 144 self.assertIn(imported_file_name, transitive_imports_paths) | |
| 145 self.assertIn(second_level_imported_file_name, transitive_imports_paths) | |
| 146 | |
| 147 self.assertEquals('AnInterface', mod.interfaces[0].name) | |
| 148 # Interfaces should be assigned their name as their spec. | |
| 149 self.assertEquals('AnInterface', mod.interfaces[0].spec) | |
| 150 self.assertEquals(mojom_struct.decl_data.short_name, mod.structs[0].name) | |
| 151 # The struct was given a full_identifier so its spec should be that. | |
| 152 self.assertEquals(mojom_struct.decl_data.full_identifier, | |
| 153 mod.structs[0].spec) | |
| 154 self.assertEquals(mojom_union.decl_data.short_name, mod.unions[0].name) | |
| 155 # The union was given a short name but not a full_identifier so its spec | |
| 156 # should be the short name. | |
| 157 self.assertEquals(mojom_union.decl_data.short_name, | |
| 158 mod.unions[0].spec) | |
| 159 self.assertEquals(mojom_enum.decl_data.short_name, mod.enums[0].name) | |
| 160 self.assertEquals(mojom_const.decl_data.short_name, mod.constants[0].name) | |
| 161 | |
| 162 imported_mod = mojom_translator.FileTranslator( | |
| 163 graph, imported_file_name).Translate() | |
| 164 self.assertFalse(imported_mod.specified_name) | |
| 165 | |
| 166 def test_no_imports(self): | |
| 167 graph = mojom_files_mojom.MojomFileGraph( | |
| 168 resolved_types={}) | |
| 169 file_name = 'root/f.mojom' | |
| 170 mojom_file = mojom_files_mojom.MojomFile( | |
| 171 file_name=file_name, | |
| 172 specified_file_name='', | |
| 173 module_namespace='somens') | |
| 174 graph.files = { file_name: mojom_file } | |
| 175 | |
| 176 # Should not throw exceptions despite imports not being set on the file. | |
| 177 mod = mojom_translator.FileTranslator(graph, file_name).Translate() | |
| 178 | |
| 179 self.assertEquals([], mod.imports) | |
| 180 | |
| 181 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 182 class TestUserDefinedFromTypeRef(unittest.TestCase): | |
| 183 | |
| 184 def do_interface_test(self, nullable, interface_request): | |
| 185 # Build a MojomInterface | |
| 186 file_name = 'a.mojom' | |
| 187 mojom_interface = mojom_types_mojom.MojomInterface( | |
| 188 decl_data=mojom_types_mojom.DeclarationData( | |
| 189 short_name='AnInterface', | |
| 190 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 191 file_name=file_name))) | |
| 192 mojom_interface.methods={} | |
| 193 | |
| 194 # Register the MojomInterface in a MojomFileGraph | |
| 195 graph = mojom_files_mojom.MojomFileGraph() | |
| 196 type_key = 'some_type_key' | |
| 197 graph.resolved_types = { | |
| 198 type_key: mojom_types_mojom.UserDefinedType( | |
| 199 interface_type=mojom_interface)} | |
| 200 | |
| 201 # Build a reference to the interface. | |
| 202 type_ref = mojom_types_mojom.Type( | |
| 203 type_reference=mojom_types_mojom.TypeReference( | |
| 204 type_key=type_key, | |
| 205 nullable=nullable, | |
| 206 is_interface_request=interface_request)) | |
| 207 | |
| 208 # Construct a translator | |
| 209 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 210 | |
| 211 # Translate the MojomInterface referenced by type_ref. | |
| 212 interface = translator.UserDefinedFromTypeRef(type_ref) | |
| 213 | |
| 214 # Check the translation | |
| 215 if interface_request: | |
| 216 self.assertEquals('AnInterface', interface.kind.name) | |
| 217 self.assertEquals('some_type_key', interface.kind.type_key) | |
| 218 else: | |
| 219 self.assertEquals('AnInterface', interface.name) | |
| 220 self.assertEquals('some_type_key', interface.type_key) | |
| 221 self.assertEquals(nullable, interface.is_nullable) | |
| 222 self.assertEquals(interface_request, isinstance(interface, | |
| 223 module.InterfaceRequest)) | |
| 224 | |
| 225 def test_interfaces(self): | |
| 226 self.do_interface_test(False, False) | |
| 227 self.do_interface_test(False, True) | |
| 228 self.do_interface_test(True, False) | |
| 229 self.do_interface_test(True, True) | |
| 230 | |
| 231 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 232 class TestUserDefinedTypeFromMojom(unittest.TestCase): | |
| 233 | |
| 234 def test_structs(self): | |
| 235 file_name = 'a.mojom' | |
| 236 graph = mojom_files_mojom.MojomFileGraph() | |
| 237 mojom_file = mojom_files_mojom.MojomFile( | |
| 238 file_name='a.mojom', | |
| 239 module_namespace='foo.bar') | |
| 240 graph.files = {mojom_file.file_name: mojom_file} | |
| 241 | |
| 242 mojom_struct = mojom_types_mojom.MojomStruct( | |
| 243 decl_data=mojom_types_mojom.DeclarationData(short_name='FirstStruct')) | |
| 244 mojom_struct.fields = [ | |
| 245 mojom_types_mojom.StructField( | |
| 246 decl_data=mojom_types_mojom.DeclarationData( | |
| 247 short_name='field03', | |
| 248 declaration_order=2), | |
| 249 type=mojom_types_mojom.Type( | |
| 250 simple_type=mojom_types_mojom.SimpleType.BOOL), | |
| 251 offset=21, | |
| 252 bit=6, | |
| 253 min_version=11), | |
| 254 mojom_types_mojom.StructField( | |
| 255 decl_data=mojom_types_mojom.DeclarationData( | |
| 256 short_name='field01', | |
| 257 declared_ordinal=1, | |
| 258 declaration_order=0), | |
| 259 type=mojom_types_mojom.Type( | |
| 260 simple_type=mojom_types_mojom.SimpleType.BOOL), | |
| 261 offset=17, | |
| 262 bit=1, | |
| 263 min_version=4), | |
| 264 mojom_types_mojom.StructField( | |
| 265 decl_data=mojom_types_mojom.DeclarationData( | |
| 266 short_name='field02', | |
| 267 declaration_order=1), | |
| 268 type=mojom_types_mojom.Type( | |
| 269 simple_type=mojom_types_mojom.SimpleType.DOUBLE), | |
| 270 offset=0, | |
| 271 bit=0, | |
| 272 min_version=0, | |
| 273 default_value=mojom_types_mojom.DefaultFieldValue( | |
| 274 value=mojom_types_mojom.Value( | |
| 275 literal_value=mojom_types_mojom.LiteralValue(double_value=15)))), | |
| 276 ] | |
| 277 mojom_struct.version_info=[ | |
| 278 mojom_types_mojom.StructVersion( | |
| 279 version_number=0, num_bytes=67, num_fields=1), | |
| 280 mojom_types_mojom.StructVersion( | |
| 281 version_number=1, num_bytes=76, num_fields=3), | |
| 282 ] | |
| 283 # mojom_fields_declaration_order lists, in declaration order, the indices | |
| 284 # of the fields in mojom_types_mojom.StructField. | |
| 285 mojom_fields_declaration_order = [1, 2, 0] | |
| 286 mojom_struct.decl_data.source_file_info = mojom_types_mojom.SourceFileInfo( | |
| 287 file_name=mojom_file.file_name) | |
| 288 | |
| 289 struct = module.Struct() | |
| 290 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 291 translator.StructFromMojom( | |
| 292 struct, mojom_types_mojom.UserDefinedType(struct_type=mojom_struct)) | |
| 293 | |
| 294 self.assertEquals('FirstStruct', struct.name) | |
| 295 self.assertEquals(translator._module, struct.module) | |
| 296 | |
| 297 self.assertEquals(len(mojom_struct.fields), len(struct.fields)) | |
| 298 for index, gold_index in enumerate(mojom_fields_declaration_order): | |
| 299 gold = mojom_struct.fields[gold_index] | |
| 300 f = struct.fields[index] | |
| 301 self.assertEquals(f.name, gold.decl_data.short_name) | |
| 302 if gold.decl_data.declared_ordinal >= 0: | |
| 303 self.assertEquals(gold.decl_data.declared_ordinal, f.ordinal) | |
| 304 else: | |
| 305 self.assertEquals(None, f.ordinal) | |
| 306 self.assertEquals(gold_index, f.computed_ordinal) | |
| 307 self.assertEquals(gold.offset, f.computed_offset) | |
| 308 self.assertEquals(gold.bit, f.computed_bit) | |
| 309 self.assertEquals(gold.min_version, f.computed_min_version) | |
| 310 self.assertEquals(struct.fields_in_ordinal_order[index].name, | |
| 311 mojom_struct.fields[index].decl_data.short_name) | |
| 312 | |
| 313 self.assertEquals(2, len(struct.versions)) | |
| 314 for i in xrange(0, 2): | |
| 315 self.assertEquals(mojom_struct.version_info[i].version_number, | |
| 316 struct.versions[i].version) | |
| 317 self.assertEquals(mojom_struct.version_info[i].num_bytes, | |
| 318 struct.versions[i].num_bytes) | |
| 319 self.assertEquals(mojom_struct.version_info[i].num_fields, | |
| 320 struct.versions[i].num_fields) | |
| 321 | |
| 322 self.assertEquals(module.BOOL, struct.fields[0].kind) | |
| 323 self.assertEquals(module.DOUBLE, struct.fields[1].kind) | |
| 324 | |
| 325 self.assertEquals('15.0', struct.fields[1].default) | |
| 326 | |
| 327 def test_constant(self): | |
| 328 file_name = 'a.mojom' | |
| 329 graph = mojom_files_mojom.MojomFileGraph() | |
| 330 | |
| 331 mojom_const = mojom_types_mojom.DeclaredConstant() | |
| 332 mojom_const.decl_data = mojom_types_mojom.DeclarationData( | |
| 333 short_name='foo', container_type_key='struct_key') | |
| 334 mojom_const.type = mojom_types_mojom.Type( | |
| 335 simple_type=mojom_types_mojom.SimpleType.INT64) | |
| 336 mojom_const.value = mojom_types_mojom.Value() | |
| 337 mojom_const.value.literal_value = mojom_types_mojom.LiteralValue( | |
| 338 int64_value=20) | |
| 339 | |
| 340 mojom_struct = mojom_types_mojom.MojomStruct( | |
| 341 fields=[], | |
| 342 decl_data=mojom_types_mojom.DeclarationData( | |
| 343 short_name='AStruct', | |
| 344 source_file_info =mojom_types_mojom.SourceFileInfo( | |
| 345 file_name=file_name))) | |
| 346 add_version_info(mojom_struct, 0) | |
| 347 graph.resolved_types = {'struct_key': mojom_types_mojom.UserDefinedType( | |
| 348 struct_type=mojom_struct)} | |
| 349 | |
| 350 const = module.Constant() | |
| 351 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 352 translator.ConstantFromMojom(const, mojom_const) | |
| 353 | |
| 354 self.assertEquals(mojom_const.decl_data.short_name, const.name) | |
| 355 self.assertEquals(module.INT64, const.kind) | |
| 356 self.assertEquals('20', const.value) | |
| 357 self.assertEquals(translator.UserDefinedFromTypeKey('struct_key'), | |
| 358 const.parent_kind) | |
| 359 | |
| 360 def test_enum(self): | |
| 361 file_name = 'a.mojom' | |
| 362 mojom_enum = mojom_types_mojom.MojomEnum() | |
| 363 mojom_enum.decl_data = mojom_types_mojom.DeclarationData( | |
| 364 short_name='AnEnum', | |
| 365 source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name)) | |
| 366 value1 = mojom_types_mojom.EnumValue( | |
| 367 decl_data=mojom_types_mojom.DeclarationData(short_name='val1'), | |
| 368 initializer_value=mojom_types_mojom.Value( | |
| 369 literal_value=mojom_types_mojom.LiteralValue(uint64_value=20)), | |
| 370 int_value=20) | |
| 371 value2 = mojom_types_mojom.EnumValue( | |
| 372 decl_data=mojom_types_mojom.DeclarationData(short_name='val2'), | |
| 373 int_value=70) | |
| 374 mojom_enum.values = [value1, value2] | |
| 375 | |
| 376 | |
| 377 graph = mojom_files_mojom.MojomFileGraph() | |
| 378 enum = module.Enum() | |
| 379 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 380 translator.EnumFromMojom( | |
| 381 enum, mojom_types_mojom.UserDefinedType(enum_type=mojom_enum)) | |
| 382 | |
| 383 self.assertEquals(translator._module, enum.module) | |
| 384 self.assertEquals(mojom_enum.decl_data.short_name, enum.name) | |
| 385 self.assertEquals(len(mojom_enum.values), len(enum.fields)) | |
| 386 | |
| 387 self.assertEquals(value1.decl_data.short_name, enum.fields[0].name) | |
| 388 self.assertEquals(value2.decl_data.short_name, enum.fields[1].name) | |
| 389 | |
| 390 self.assertEquals('20', enum.fields[0].value) | |
| 391 self.assertIsNone(enum.fields[1].value) | |
| 392 | |
| 393 self.assertEquals(value1.int_value, | |
| 394 enum.fields[0].numeric_value) | |
| 395 self.assertEquals(value2.int_value, | |
| 396 enum.fields[1].numeric_value) | |
| 397 | |
| 398 def test_child_enum(self): | |
| 399 file_name = 'a.mojom' | |
| 400 mojom_enum = mojom_types_mojom.MojomEnum() | |
| 401 mojom_enum.decl_data = mojom_types_mojom.DeclarationData( | |
| 402 short_name='AnEnum', | |
| 403 source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name), | |
| 404 container_type_key='struct_key') | |
| 405 mojom_enum.values = [] | |
| 406 | |
| 407 graph = mojom_files_mojom.MojomFileGraph() | |
| 408 mojom_struct = mojom_types_mojom.MojomStruct( | |
| 409 fields=[], | |
| 410 decl_data=mojom_types_mojom.DeclarationData( | |
| 411 short_name='AStruct', | |
| 412 source_file_info =mojom_types_mojom.SourceFileInfo( | |
| 413 file_name=file_name))) | |
| 414 add_version_info(mojom_struct, 0) | |
| 415 graph.resolved_types = {'struct_key': mojom_types_mojom.UserDefinedType( | |
| 416 struct_type=mojom_struct)} | |
| 417 | |
| 418 enum = module.Enum() | |
| 419 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 420 translator.EnumFromMojom( | |
| 421 enum, mojom_types_mojom.UserDefinedType(enum_type=mojom_enum)) | |
| 422 | |
| 423 self.assertEquals(mojom_enum.decl_data.short_name, enum.name) | |
| 424 self.assertEquals(len(mojom_enum.values), len(enum.fields)) | |
| 425 | |
| 426 def test_unions(self): | |
| 427 file_name = 'a.mojom' | |
| 428 mojom_union = mojom_types_mojom.MojomUnion() | |
| 429 mojom_union.decl_data = mojom_types_mojom.DeclarationData( | |
| 430 short_name='AUnion', | |
| 431 source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name)) | |
| 432 | |
| 433 field1 = mojom_types_mojom.UnionField( | |
| 434 decl_data=mojom_types_mojom.DeclarationData(short_name='field1', | |
| 435 declaration_order=0, declared_ordinal=7), | |
| 436 type=mojom_types_mojom.Type( | |
| 437 simple_type=mojom_types_mojom.SimpleType.BOOL), | |
| 438 tag=7) | |
| 439 field2 = mojom_types_mojom.UnionField( | |
| 440 decl_data=mojom_types_mojom.DeclarationData( | |
| 441 short_name='field2', declaration_order=1), | |
| 442 type=mojom_types_mojom.Type( | |
| 443 simple_type=mojom_types_mojom.SimpleType.DOUBLE), | |
| 444 tag=8) | |
| 445 field3 = mojom_types_mojom.UnionField( | |
| 446 decl_data=mojom_types_mojom.DeclarationData(short_name='field3', | |
| 447 declaration_order=2, declared_ordinal=0), | |
| 448 type=mojom_types_mojom.Type( | |
| 449 simple_type=mojom_types_mojom.SimpleType.INT32), | |
| 450 tag=0) | |
| 451 | |
| 452 mojom_union.fields = [field3, field1, field2] | |
| 453 # mojom_fields_declaration_order lists, in declaration order, the indices | |
| 454 # of the fields in mojom_union.fields | |
| 455 mojom_fields_declaration_order = [1, 2, 0] | |
| 456 | |
| 457 graph = mojom_files_mojom.MojomFileGraph() | |
| 458 union = module.Union() | |
| 459 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 460 translator.UnionFromMojom( | |
| 461 union, mojom_types_mojom.UserDefinedType(union_type=mojom_union)) | |
| 462 | |
| 463 self.assertEquals(translator._module, union.module) | |
| 464 self.assertEquals('AUnion', union.name) | |
| 465 self.assertEquals(len(mojom_union.fields), len(union.fields)) | |
| 466 | |
| 467 for index, gold_index in enumerate(mojom_fields_declaration_order): | |
| 468 gold = mojom_union.fields[gold_index] | |
| 469 f = union.fields[index] | |
| 470 self.assertEquals(gold.decl_data.short_name, f.name) | |
| 471 if gold.decl_data.declared_ordinal >= 0: | |
| 472 self.assertEquals(gold.decl_data.declared_ordinal, f.declared_tag) | |
| 473 else: | |
| 474 self.assertEquals(None, f.declared_tag) | |
| 475 self.assertEquals(gold.tag, f.ordinal) | |
| 476 | |
| 477 self.assertEquals(module.BOOL, union.fields[0].kind) | |
| 478 self.assertEquals(module.DOUBLE, union.fields[1].kind) | |
| 479 self.assertEquals(module.INT32, union.fields[2].kind) | |
| 480 | |
| 481 def literal_value(self, x): | |
| 482 """Creates a typed literal value containing the value |x|. | |
| 483 | |
| 484 Args: | |
| 485 x: A string, int, float or bool value. | |
| 486 | |
| 487 Returns: | |
| 488 {mojom_types.LiteralValue} with an appropriately typed value. | |
| 489 """ | |
| 490 if isinstance(x, str): | |
| 491 return mojom_types_mojom.LiteralValue(string_value=x) | |
| 492 elif isinstance(x, int): | |
| 493 return mojom_types_mojom.LiteralValue(int64_value=x) | |
| 494 elif isinstance(x, float): | |
| 495 return mojom_types_mojom.LiteralValue(double_value=x) | |
| 496 elif isinstance(x, bool): | |
| 497 return mojom_types_mojom.LiteralValue(bool_value=x) | |
| 498 raise Exception("unexpected type(x)=%s" % type(x)) | |
| 499 | |
| 500 | |
| 501 def test_attributes(self): | |
| 502 mojom_enum = mojom_types_mojom.MojomEnum() | |
| 503 mojom_enum.decl_data = mojom_types_mojom.DeclarationData() | |
| 504 gold = { | |
| 505 'foo': 'bar', | |
| 506 'other': 'thing', | |
| 507 'hello': 'world', | |
| 508 'min_version': 2, | |
| 509 'pi': 3.14159, | |
| 510 'is_happy': True | |
| 511 } | |
| 512 mojom_enum.decl_data.attributes = [] | |
| 513 for key, value in gold.iteritems(): | |
| 514 mojom_enum.decl_data.attributes.append( | |
| 515 mojom_types_mojom.Attribute(key=key, value=self.literal_value(value))) | |
| 516 | |
| 517 graph = mojom_files_mojom.MojomFileGraph() | |
| 518 attributes = mojom_translator.FileTranslator( | |
| 519 graph, None).AttributesFromMojom(mojom_enum) | |
| 520 | |
| 521 self.assertEquals(gold, attributes) | |
| 522 | |
| 523 def test_attributes_none(self): | |
| 524 mojom_enum = mojom_types_mojom.MojomEnum() | |
| 525 mojom_enum.decl_data = mojom_types_mojom.DeclarationData() | |
| 526 graph = mojom_files_mojom.MojomFileGraph() | |
| 527 attributes = mojom_translator.FileTranslator( | |
| 528 graph, None).AttributesFromMojom(mojom_enum) | |
| 529 self.assertFalse(attributes) | |
| 530 | |
| 531 def test_imported_struct(self): | |
| 532 graph = mojom_files_mojom.MojomFileGraph() | |
| 533 | |
| 534 graph.files = { | |
| 535 'a.mojom': mojom_files_mojom.MojomFile( | |
| 536 file_name='a.mojom', | |
| 537 specified_file_name='', | |
| 538 module_namespace='namespace', | |
| 539 imports=['root/c.mojom']), | |
| 540 'root/c.mojom': mojom_files_mojom.MojomFile( | |
| 541 file_name='root/c.mojom', | |
| 542 specified_file_name='', | |
| 543 module_namespace='otherns', | |
| 544 imports=[]), | |
| 545 } | |
| 546 | |
| 547 mojom_struct = mojom_types_mojom.MojomStruct() | |
| 548 mojom_struct.decl_data = mojom_types_mojom.DeclarationData( | |
| 549 short_name='AStruct', | |
| 550 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 551 file_name='root/c.mojom')) | |
| 552 mojom_struct.fields = [] | |
| 553 add_version_info(mojom_struct, 0) | |
| 554 | |
| 555 type_key = 'some_type_key' | |
| 556 graph.resolved_types = { | |
| 557 type_key: mojom_types_mojom.UserDefinedType(struct_type=mojom_struct)} | |
| 558 struct = module.Struct() | |
| 559 | |
| 560 # Translate should create the imports. | |
| 561 translator = mojom_translator.FileTranslator(graph, 'a.mojom') | |
| 562 translator.Translate() | |
| 563 | |
| 564 struct = translator.UserDefinedFromTypeRef( | |
| 565 mojom_types_mojom.Type( | |
| 566 type_reference=mojom_types_mojom.TypeReference( | |
| 567 type_key=type_key))) | |
| 568 | |
| 569 self.assertEquals( | |
| 570 translator._transitive_imports['root/c.mojom']['module'], struct.module) | |
| 571 self.assertEquals( | |
| 572 translator._transitive_imports['root/c.mojom'], struct.imported_from) | |
| 573 | |
| 574 def test_interface(self): | |
| 575 self.do_interface_test(True) | |
| 576 self.do_interface_test(False) | |
| 577 | |
| 578 def do_interface_test(self, specify_service_name): | |
| 579 file_name = 'a.mojom' | |
| 580 mojom_interface = mojom_types_mojom.MojomInterface( | |
| 581 current_version=47, | |
| 582 decl_data=mojom_types_mojom.DeclarationData( | |
| 583 short_name='AnInterface', | |
| 584 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 585 file_name=file_name))) | |
| 586 if specify_service_name: | |
| 587 mojom_interface.service_name = 'test::TheInterface' | |
| 588 mojom_interface.decl_data.attributes = [mojom_types_mojom.Attribute( | |
| 589 key='ServiceName', value=mojom_types_mojom.LiteralValue( | |
| 590 string_value='test::TheInterface'))] | |
| 591 else: | |
| 592 mojom_interface.service_name = None | |
| 593 mojom_method10 = mojom_types_mojom.MojomMethod( | |
| 594 ordinal=10, | |
| 595 decl_data=mojom_types_mojom.DeclarationData( | |
| 596 short_name='AMethod10', | |
| 597 declaration_order=1, | |
| 598 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 599 file_name=file_name)), | |
| 600 parameters=mojom_types_mojom.MojomStruct(fields=[], | |
| 601 version_info=build_version_info(0), | |
| 602 decl_data=build_decl_data('AMethod10_Request'))) | |
| 603 mojom_method0 = mojom_types_mojom.MojomMethod( | |
| 604 ordinal=0, | |
| 605 decl_data=mojom_types_mojom.DeclarationData( | |
| 606 short_name='AMethod0', | |
| 607 declaration_order=1, | |
| 608 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 609 file_name=file_name)), | |
| 610 parameters=mojom_types_mojom.MojomStruct(fields=[], | |
| 611 version_info=build_version_info(0), | |
| 612 decl_data=build_decl_data('AMethod0_Request'))) | |
| 613 mojom_method7 = mojom_types_mojom.MojomMethod( | |
| 614 ordinal=7, | |
| 615 decl_data=mojom_types_mojom.DeclarationData( | |
| 616 short_name='AMethod7', | |
| 617 declaration_order=0, | |
| 618 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 619 file_name=file_name)), | |
| 620 parameters=mojom_types_mojom.MojomStruct(fields=[], | |
| 621 version_info=build_version_info(0), | |
| 622 decl_data=build_decl_data('AMethod7_Request'))) | |
| 623 mojom_interface.methods = {10: mojom_method10, 0: mojom_method0, | |
| 624 7: mojom_method7} | |
| 625 | |
| 626 interface = module.Interface() | |
| 627 graph = mojom_files_mojom.MojomFileGraph() | |
| 628 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 629 translator.InterfaceFromMojom(interface, mojom_types_mojom.UserDefinedType( | |
| 630 interface_type=mojom_interface)) | |
| 631 | |
| 632 | |
| 633 self.assertEquals(translator._module, interface.module) | |
| 634 self.assertEquals('AnInterface', interface.name) | |
| 635 self.assertEquals(mojom_interface.current_version, interface.version) | |
| 636 # The methods should be ordered by declaration_order. | |
| 637 self.assertEquals(7, interface.methods[0].ordinal) | |
| 638 self.assertEquals(0, interface.methods[1].ordinal) | |
| 639 self.assertEquals(10, interface.methods[2].ordinal) | |
| 640 if specify_service_name: | |
| 641 self.assertEquals('test::TheInterface', interface.service_name) | |
| 642 else: | |
| 643 self.assertEquals(None, interface.service_name) | |
| 644 | |
| 645 # TODO(azani): Add the contained declarations. | |
| 646 | |
| 647 def test_method(self): | |
| 648 file_name = 'a.mojom' | |
| 649 mojom_method = mojom_types_mojom.MojomMethod( | |
| 650 ordinal=10, | |
| 651 min_version=6, | |
| 652 decl_data=mojom_types_mojom.DeclarationData( | |
| 653 short_name='AMethod', | |
| 654 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 655 file_name=file_name))) | |
| 656 | |
| 657 param1 = mojom_types_mojom.StructField( | |
| 658 decl_data=mojom_types_mojom.DeclarationData(short_name='a_param'), | |
| 659 type=mojom_types_mojom.Type( | |
| 660 simple_type=mojom_types_mojom.SimpleType.UINT32), | |
| 661 offset=21, | |
| 662 bit=6, | |
| 663 min_version=11) | |
| 664 param2 = mojom_types_mojom.StructField( | |
| 665 decl_data=mojom_types_mojom.DeclarationData(short_name='b_param'), | |
| 666 type=mojom_types_mojom.Type( | |
| 667 simple_type=mojom_types_mojom.SimpleType.UINT64), | |
| 668 offset=22, | |
| 669 bit=7, | |
| 670 min_version=12) | |
| 671 mojom_method.parameters = mojom_types_mojom.MojomStruct( | |
| 672 fields=[param1, param2], | |
| 673 version_info=build_version_info(2), | |
| 674 decl_data=build_decl_data('Not used')) | |
| 675 | |
| 676 interface = module.Interface('MyInterface') | |
| 677 graph = mojom_files_mojom.MojomFileGraph() | |
| 678 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 679 method = translator.MethodFromMojom(mojom_method, interface) | |
| 680 | |
| 681 self.assertEquals(mojom_method.decl_data.short_name, method.name) | |
| 682 self.assertEquals(interface, method.interface) | |
| 683 self.assertEquals(mojom_method.ordinal, method.ordinal) | |
| 684 self.assertEquals(mojom_method.min_version, method.min_version) | |
| 685 self.assertIsNone(method.response_parameters) | |
| 686 self.assertEquals( | |
| 687 len(mojom_method.parameters.fields), len(method.parameters)) | |
| 688 self.assertEquals(param1.decl_data.short_name, method.parameters[0].name) | |
| 689 self.assertEquals(param2.decl_data.short_name, method.parameters[1].name) | |
| 690 self.assertEquals('MyInterface_AMethod_Params', method.param_struct.name) | |
| 691 self.assertEquals(len(mojom_method.parameters.fields), | |
| 692 len(method.param_struct.fields)) | |
| 693 for i in xrange(0, len(mojom_method.parameters.fields)): | |
| 694 gold = mojom_method.parameters.fields[i] | |
| 695 f = method.param_struct.fields_in_ordinal_order[i] | |
| 696 self.assertEquals(gold.decl_data.short_name, f.name) | |
| 697 self.assertEquals(gold.offset, f.computed_offset) | |
| 698 self.assertEquals(gold.bit, f.computed_bit) | |
| 699 self.assertEquals(gold.min_version, f.computed_min_version) | |
| 700 | |
| 701 # Add empty return params. | |
| 702 mojom_method.response_params = mojom_types_mojom.MojomStruct(fields=[]) | |
| 703 add_version_info(mojom_method.response_params, 0) | |
| 704 add_decl_data(mojom_method.response_params, 'AMethod_Response') | |
| 705 method = translator.MethodFromMojom(mojom_method, interface) | |
| 706 self.assertEquals([], method.response_parameters) | |
| 707 | |
| 708 # Add non-empty return params. | |
| 709 mojom_method.response_params.fields = [param1] | |
| 710 method = translator.MethodFromMojom(mojom_method, interface) | |
| 711 self.assertEquals( | |
| 712 param1.decl_data.short_name, method.response_parameters[0].name) | |
| 713 | |
| 714 def test_parameter(self): | |
| 715 # Parameters are encoded as fields in a struct. | |
| 716 mojom_param = mojom_types_mojom.StructField( | |
| 717 decl_data=mojom_types_mojom.DeclarationData( | |
| 718 short_name='param0', | |
| 719 declared_ordinal=5), | |
| 720 type=mojom_types_mojom.Type( | |
| 721 simple_type=mojom_types_mojom.SimpleType.UINT64), | |
| 722 default_value=mojom_types_mojom.Value( | |
| 723 literal_value=mojom_types_mojom.LiteralValue(uint64_value=20))) | |
| 724 | |
| 725 graph = mojom_files_mojom.MojomFileGraph() | |
| 726 translator = mojom_translator.FileTranslator(graph, '') | |
| 727 param = translator.ParamFromMojom(mojom_param) | |
| 728 | |
| 729 self.assertEquals(mojom_param.decl_data.short_name, param.name) | |
| 730 self.assertEquals(module.UINT64, param.kind) | |
| 731 self.assertEquals(mojom_param.decl_data.declared_ordinal, param.ordinal) | |
| 732 | |
| 733 def test_contained_declarations(self): | |
| 734 graph = mojom_files_mojom.MojomFileGraph() | |
| 735 file_name = 'root/f.mojom' | |
| 736 | |
| 737 mojom_enum = mojom_types_mojom.MojomEnum( | |
| 738 values=[], | |
| 739 decl_data=mojom_types_mojom.DeclarationData( | |
| 740 short_name='AnEnum', | |
| 741 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 742 file_name=file_name), | |
| 743 container_type_key='parent_key')) | |
| 744 graph.resolved_types = { | |
| 745 'enum_key': mojom_types_mojom.UserDefinedType(enum_type=mojom_enum)} | |
| 746 | |
| 747 mojom_const = mojom_types_mojom.DeclaredConstant( | |
| 748 decl_data=mojom_types_mojom.DeclarationData( | |
| 749 short_name='AConst', | |
| 750 container_type_key='parent_key'), | |
| 751 type=mojom_types_mojom.Type( | |
| 752 simple_type=mojom_types_mojom.SimpleType.INT64), | |
| 753 value=mojom_types_mojom.Value( | |
| 754 literal_value=mojom_types_mojom.LiteralValue( | |
| 755 int64_value=30))) | |
| 756 graph.resolved_constants = {'constant_key': mojom_const} | |
| 757 | |
| 758 contained_declarations = mojom_types_mojom.ContainedDeclarations( | |
| 759 enums=['enum_key'], constants=['constant_key']) | |
| 760 | |
| 761 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 762 struct = module.Struct(name='parent') | |
| 763 translator._type_cache['parent_key'] = struct | |
| 764 translator.PopulateContainedDeclarationsFromMojom( | |
| 765 struct, contained_declarations) | |
| 766 | |
| 767 self.assertEquals( | |
| 768 mojom_enum.decl_data.short_name, struct.enums[0].name) | |
| 769 self.assertEquals(struct, struct.enums[0].parent_kind) | |
| 770 self.assertEquals( | |
| 771 mojom_const.decl_data.short_name, struct.constants[0].name) | |
| 772 self.assertEquals(struct, struct.constants[0].parent_kind) | |
| 773 | |
| 774 | |
| 775 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 776 class TestValueFromMojom(unittest.TestCase): | |
| 777 | |
| 778 def test_literal_value(self): | |
| 779 mojom_int64 = mojom_types_mojom.Value() | |
| 780 mojom_int64.literal_value = mojom_types_mojom.LiteralValue(int64_value=20) | |
| 781 mojom_bool = mojom_types_mojom.Value() | |
| 782 mojom_bool.literal_value = mojom_types_mojom.LiteralValue(bool_value=True) | |
| 783 mojom_double = mojom_types_mojom.Value() | |
| 784 mojom_double.literal_value = mojom_types_mojom.LiteralValue( | |
| 785 double_value=1234.012345678901) | |
| 786 | |
| 787 graph = mojom_files_mojom.MojomFileGraph() | |
| 788 int64_const = mojom_translator.FileTranslator(graph, None).ValueFromMojom( | |
| 789 mojom_int64) | |
| 790 bool_const = mojom_translator.FileTranslator(graph, None).ValueFromMojom( | |
| 791 mojom_bool) | |
| 792 double_const = mojom_translator.FileTranslator(graph, None).ValueFromMojom( | |
| 793 mojom_double) | |
| 794 | |
| 795 self.assertEquals('20', int64_const) | |
| 796 self.assertEquals('true', bool_const) | |
| 797 self.assertEquals('1234.012345678901', double_const) | |
| 798 | |
| 799 def test_builtin_const(self): | |
| 800 mojom = mojom_types_mojom.Value() | |
| 801 | |
| 802 graph = mojom_files_mojom.MojomFileGraph() | |
| 803 | |
| 804 gold = [ | |
| 805 (mojom_types_mojom.BuiltinConstantValue.DOUBLE_INFINITY, | |
| 806 'double.INFINITY'), | |
| 807 (mojom_types_mojom.BuiltinConstantValue.DOUBLE_NEGATIVE_INFINITY, | |
| 808 'double.NEGATIVE_INFINITY'), | |
| 809 (mojom_types_mojom.BuiltinConstantValue.DOUBLE_NAN, | |
| 810 'double.NAN'), | |
| 811 (mojom_types_mojom.BuiltinConstantValue.FLOAT_INFINITY, | |
| 812 'float.INFINITY'), | |
| 813 (mojom_types_mojom.BuiltinConstantValue.FLOAT_NEGATIVE_INFINITY, | |
| 814 'float.NEGATIVE_INFINITY'), | |
| 815 (mojom_types_mojom.BuiltinConstantValue.FLOAT_NAN, 'float.NAN'), | |
| 816 ] | |
| 817 | |
| 818 for mojom_builtin, string in gold: | |
| 819 mojom.builtin_value = mojom_builtin | |
| 820 const = mojom_translator.FileTranslator(graph, None).ValueFromMojom(mojom) | |
| 821 self.assertIsInstance(const, module.BuiltinValue) | |
| 822 self.assertEquals(string, const.value) | |
| 823 | |
| 824 def test_enum_value(self): | |
| 825 file_name = 'a.mojom' | |
| 826 mojom_enum = mojom_types_mojom.MojomEnum() | |
| 827 mojom_enum.decl_data = mojom_types_mojom.DeclarationData( | |
| 828 short_name='AnEnum', | |
| 829 source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name)) | |
| 830 value1 = mojom_types_mojom.EnumValue( | |
| 831 decl_data=mojom_types_mojom.DeclarationData( | |
| 832 short_name='val1', | |
| 833 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 834 file_name=file_name)), | |
| 835 initializer_value=mojom_types_mojom.Value( | |
| 836 literal_value=mojom_types_mojom.LiteralValue(uint64_value=20)), | |
| 837 int_value=20) | |
| 838 value2 = mojom_types_mojom.EnumValue( | |
| 839 decl_data=mojom_types_mojom.DeclarationData(short_name='val2'), | |
| 840 int_value=70) | |
| 841 mojom_enum.values = [value1, value2] | |
| 842 | |
| 843 graph = mojom_files_mojom.MojomFileGraph() | |
| 844 graph.resolved_types = { | |
| 845 'enum_key': mojom_types_mojom.UserDefinedType(enum_type=mojom_enum)} | |
| 846 | |
| 847 mojom = mojom_types_mojom.Value( | |
| 848 enum_value_reference=mojom_types_mojom.EnumValueReference( | |
| 849 identifier='SOMEID', | |
| 850 enum_type_key='enum_key', | |
| 851 enum_value_index=0)) | |
| 852 | |
| 853 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 854 enum_value = translator.ValueFromMojom(mojom) | |
| 855 enum = translator.UserDefinedFromTypeKey('enum_key') | |
| 856 | |
| 857 self.assertIs(enum, enum_value.enum) | |
| 858 self.assertIs(value1.decl_data.short_name, enum_value.name) | |
| 859 | |
| 860 def test_constant_value(self): | |
| 861 file_name = 'a.mojom' | |
| 862 mojom_const = mojom_types_mojom.DeclaredConstant( | |
| 863 decl_data=mojom_types_mojom.DeclarationData( | |
| 864 short_name='AConst', | |
| 865 source_file_info=mojom_types_mojom.SourceFileInfo( | |
| 866 file_name=file_name)), | |
| 867 type=mojom_types_mojom.Type( | |
| 868 simple_type=mojom_types_mojom.SimpleType.INT64), | |
| 869 value=mojom_types_mojom.Value( | |
| 870 literal_value=mojom_types_mojom.LiteralValue( | |
| 871 int64_value=30))) | |
| 872 | |
| 873 graph = mojom_files_mojom.MojomFileGraph() | |
| 874 graph.resolved_constants = {'constant_key': mojom_const} | |
| 875 | |
| 876 mojom = mojom_types_mojom.Value( | |
| 877 constant_reference=mojom_types_mojom.ConstantReference( | |
| 878 identifier='SOMEID', | |
| 879 constant_key='constant_key')) | |
| 880 | |
| 881 translator = mojom_translator.FileTranslator(graph, file_name) | |
| 882 const_value = translator.ValueFromMojom(mojom) | |
| 883 self.assertIs( | |
| 884 translator.ConstantFromKey('constant_key'), const_value.constant) | |
| 885 self.assertIs(mojom_const.decl_data.short_name, const_value.name) | |
| 886 | |
| 887 | |
| 888 @unittest.skipUnless(bindings_imported, 'Could not import python bindings.') | |
| 889 class TestKindFromMojom(unittest.TestCase): | |
| 890 | |
| 891 def test_simple_type(self): | |
| 892 simple_types = [ | |
| 893 (mojom_types_mojom.SimpleType.BOOL, module.BOOL), | |
| 894 (mojom_types_mojom.SimpleType.INT8, module.INT8), | |
| 895 (mojom_types_mojom.SimpleType.INT16, module.INT16), | |
| 896 (mojom_types_mojom.SimpleType.INT32, module.INT32), | |
| 897 (mojom_types_mojom.SimpleType.INT64, module.INT64), | |
| 898 (mojom_types_mojom.SimpleType.UINT8, module.UINT8), | |
| 899 (mojom_types_mojom.SimpleType.UINT16, module.UINT16), | |
| 900 (mojom_types_mojom.SimpleType.UINT32, module.UINT32), | |
| 901 (mojom_types_mojom.SimpleType.UINT64, module.UINT64), | |
| 902 (mojom_types_mojom.SimpleType.FLOAT, module.FLOAT), | |
| 903 (mojom_types_mojom.SimpleType.DOUBLE, module.DOUBLE), | |
| 904 ] | |
| 905 | |
| 906 g = mojom_files_mojom.MojomFileGraph() | |
| 907 t = mojom_translator.FileTranslator(g, None) | |
| 908 for mojom, golden in simple_types: | |
| 909 self.assertEquals( | |
| 910 golden, t.KindFromMojom(mojom_types_mojom.Type(simple_type=mojom))) | |
| 911 | |
| 912 def test_handle_type(self): | |
| 913 handle_types = [ | |
| 914 (mojom_types_mojom.HandleType.Kind.UNSPECIFIED, False, | |
| 915 module.HANDLE), | |
| 916 (mojom_types_mojom.HandleType.Kind.MESSAGE_PIPE, False, | |
| 917 module.MSGPIPE), | |
| 918 (mojom_types_mojom.HandleType.Kind.DATA_PIPE_CONSUMER, False, | |
| 919 module.DCPIPE), | |
| 920 (mojom_types_mojom.HandleType.Kind.DATA_PIPE_PRODUCER, False, | |
| 921 module.DPPIPE), | |
| 922 (mojom_types_mojom.HandleType.Kind.SHARED_BUFFER, False, | |
| 923 module.SHAREDBUFFER), | |
| 924 (mojom_types_mojom.HandleType.Kind.UNSPECIFIED, True, | |
| 925 module.NULLABLE_HANDLE), | |
| 926 (mojom_types_mojom.HandleType.Kind.MESSAGE_PIPE, True, | |
| 927 module.NULLABLE_MSGPIPE), | |
| 928 (mojom_types_mojom.HandleType.Kind.DATA_PIPE_CONSUMER, True, | |
| 929 module.NULLABLE_DCPIPE), | |
| 930 (mojom_types_mojom.HandleType.Kind.DATA_PIPE_PRODUCER, True, | |
| 931 module.NULLABLE_DPPIPE), | |
| 932 (mojom_types_mojom.HandleType.Kind.SHARED_BUFFER, True, | |
| 933 module.NULLABLE_SHAREDBUFFER), | |
| 934 ] | |
| 935 g = mojom_files_mojom.MojomFileGraph() | |
| 936 t = mojom_translator.FileTranslator(g, None) | |
| 937 for mojom, nullable, golden in handle_types: | |
| 938 h = mojom_types_mojom.Type() | |
| 939 h.handle_type = mojom_types_mojom.HandleType( | |
| 940 kind=mojom, nullable=nullable) | |
| 941 self.assertEquals(golden, t.KindFromMojom(h)) | |
| 942 | |
| 943 def test_string_type(self): | |
| 944 g = mojom_files_mojom.MojomFileGraph() | |
| 945 t = mojom_translator.FileTranslator(g, None) | |
| 946 | |
| 947 s = mojom_types_mojom.Type(string_type=mojom_types_mojom.StringType()) | |
| 948 self.assertEquals(module.STRING, t.KindFromMojom(s)) | |
| 949 | |
| 950 s.string_type.nullable = True | |
| 951 self.assertEquals(module.NULLABLE_STRING, t.KindFromMojom(s)) | |
| 952 | |
| 953 def test_array_type(self): | |
| 954 array_types = [ | |
| 955 (False, False, -1), | |
| 956 (False, False, 10), | |
| 957 (True, False, -1), | |
| 958 (True, True, -1), | |
| 959 (False, True, -1), | |
| 960 (False, True, 10), | |
| 961 ] | |
| 962 g = mojom_files_mojom.MojomFileGraph() | |
| 963 t = mojom_translator.FileTranslator(g, None) | |
| 964 | |
| 965 for array_nullable, element_nullable, size in array_types: | |
| 966 a = mojom_types_mojom.Type() | |
| 967 a.array_type = mojom_types_mojom.ArrayType( | |
| 968 nullable=array_nullable, | |
| 969 fixed_length=size) | |
| 970 a.array_type.element_type = mojom_types_mojom.Type( | |
| 971 string_type=mojom_types_mojom.StringType(nullable=element_nullable)) | |
| 972 | |
| 973 result = t.KindFromMojom(a) | |
| 974 self.assertTrue(module.IsArrayKind(result)) | |
| 975 self.assertTrue(module.IsStringKind(result.kind)) | |
| 976 self.assertEquals(array_nullable, module.IsNullableKind(result)) | |
| 977 self.assertEquals(element_nullable, module.IsNullableKind(result.kind)) | |
| 978 | |
| 979 if size < 0: | |
| 980 self.assertIsNone(result.length) | |
| 981 else: | |
| 982 self.assertEquals(size, result.length) | |
| 983 | |
| 984 def test_map_type(self): | |
| 985 map_types = [ | |
| 986 (False, False), | |
| 987 (True, False), | |
| 988 (False, True), | |
| 989 (True, True), | |
| 990 ] | |
| 991 g = mojom_files_mojom.MojomFileGraph() | |
| 992 t = mojom_translator.FileTranslator(g, None) | |
| 993 | |
| 994 for map_nullable, value_nullable in map_types: | |
| 995 m = mojom_types_mojom.Type() | |
| 996 m.map_type = mojom_types_mojom.MapType( | |
| 997 nullable=map_nullable) | |
| 998 m.map_type.key_type = mojom_types_mojom.Type( | |
| 999 string_type=mojom_types_mojom.StringType()) | |
| 1000 m.map_type.value_type = mojom_types_mojom.Type( | |
| 1001 handle_type=mojom_types_mojom.HandleType( | |
| 1002 kind=mojom_types_mojom.HandleType.Kind.SHARED_BUFFER, | |
| 1003 nullable=value_nullable)) | |
| 1004 | |
| 1005 result = t.KindFromMojom(m) | |
| 1006 self.assertTrue(module.IsMapKind(result)) | |
| 1007 self.assertTrue(module.IsStringKind(result.key_kind)) | |
| 1008 self.assertTrue(module.IsSharedBufferKind(result.value_kind)) | |
| 1009 self.assertEquals(map_nullable, module.IsNullableKind(result)) | |
| 1010 self.assertEquals(value_nullable, | |
| 1011 module.IsNullableKind(result.value_kind)) | |
| 1012 | |
| 1013 def test_user_defined_type_type(self): | |
| 1014 graph = mojom_files_mojom.MojomFileGraph() | |
| 1015 mojom_struct = mojom_types_mojom.MojomStruct( | |
| 1016 decl_data=mojom_types_mojom.DeclarationData(short_name='FirstStruct')) | |
| 1017 type_key = 'some opaque string' | |
| 1018 mojom_struct.fields = [ | |
| 1019 # Make sure recursive structs are correctly handled. | |
| 1020 mojom_types_mojom.StructField( | |
| 1021 decl_data=mojom_types_mojom.DeclarationData(short_name='field00'), | |
| 1022 type=mojom_types_mojom.Type( | |
| 1023 type_reference=mojom_types_mojom.TypeReference(type_key=type_key))) | |
| 1024 ] | |
| 1025 add_version_info(mojom_struct, 1) | |
| 1026 graph.resolved_types = { | |
| 1027 type_key: mojom_types_mojom.UserDefinedType(struct_type=mojom_struct)} | |
| 1028 | |
| 1029 mojom_type = mojom_types_mojom.Type() | |
| 1030 mojom_type.type_reference = mojom_types_mojom.TypeReference( | |
| 1031 type_key=type_key) | |
| 1032 | |
| 1033 t = mojom_translator.FileTranslator(graph, None) | |
| 1034 result = t.KindFromMojom(mojom_type) | |
| 1035 self.assertTrue(module.IsStructKind(result)) | |
| 1036 self.assertEquals(mojom_struct.decl_data.short_name, result.name) | |
| 1037 self.assertEquals(result, result.fields[0].kind) | |
| 1038 self.assertEquals(type_key, result.type_key) | |
| 1039 | |
| 1040 # Make sure we create only one module object per type. | |
| 1041 result2 = t.KindFromMojom(mojom_type) | |
| 1042 self.assertIs(result, result2) | |
| 1043 | |
| 1044 # Nullable type reference | |
| 1045 mojom_type.type_reference.nullable = True | |
| 1046 nullable_result = t.KindFromMojom(mojom_type) | |
| 1047 self.assertTrue(module.IsNullableKind(nullable_result)) | |
| 1048 | |
| 1049 if __name__ == '__main__': | |
| 1050 unittest.main() | |
| 1051 | |
| 1052 def build_decl_data(short_name): | |
| 1053 """Builds and returns a DeclarationData with the given short_name. | |
| 1054 | |
| 1055 Args: | |
| 1056 short_name: {str} short_name to use | |
| 1057 | |
| 1058 Returns: | |
| 1059 {mojom_types_mojom.DeclarationData} With the given short_name | |
| 1060 """ | |
| 1061 return mojom_types_mojom.DeclarationData(short_name=short_name) | |
| 1062 | |
| 1063 def add_decl_data(element, short_name): | |
| 1064 """Builds a DeclarationData with the given short_name and adds it | |
| 1065 as the |decl_data| attribute of |element|. | |
| 1066 | |
| 1067 Args: | |
| 1068 element: {any} The Python object to which a |decl_data| attribute will be | |
| 1069 added. | |
| 1070 short_name: {str} short_name to use | |
| 1071 """ | |
| 1072 element.decl_data=build_decl_data(short_name) | |
| 1073 | |
| 1074 def build_version_info(num_fields): | |
| 1075 """Builds and returns a list containing a single StructVersion with | |
| 1076 version_number=0, num_bytes=0, and the given value for num_fields. | |
| 1077 | |
| 1078 Args: | |
| 1079 num_fields: {int} The value of num_fields to use. | |
| 1080 Returns: | |
| 1081 {[mojom_types_mojom.StructVersion]} Containing a single element with | |
| 1082 the given value for num_fields. | |
| 1083 """ | |
| 1084 return [mojom_types_mojom.StructVersion( | |
| 1085 version_number=0, num_bytes=0,num_fields=num_fields)] | |
| 1086 | |
| 1087 def add_version_info(mojom_struct, num_fields): | |
| 1088 """Builds a list containing a single StructVersion with | |
| 1089 version_number=0, num_bytes=0, and the given value for num_fields. Adds this | |
| 1090 as the |version_info| attribute of |mojom_struct|. | |
| 1091 | |
| 1092 Args: | |
| 1093 mojom_struct: {any} The Python object to which a |version_info| attribute | |
| 1094 will be added. | |
| 1095 num_fields: {int} The value of num_fields to use. | |
| 1096 """ | |
| 1097 mojom_struct.version_info=build_version_info(num_fields) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2250183003:
Make the fuchsia mojo/public repo the source of truth. (Closed)
Base URL: https://github.com/domokit/mojo.git@master