
Support for the 'internal' extended attribute for IDL in the json schema compiler was added back in: https://chromiumcodereview.appspot.com/10677015 However it is no longer used anywhere except for the tests, so it looks like we can remove it. Note: Lack of usage was verfied by searching codesearch for any generated schema files with `"internal":true`: https://source.chromium.org/search?q=f:out%2F%20%22%5C%22internal%5C%22:true%22 No behavior change is expected. Bug: 340297705 Change-Id: Ia2cceb9ac23bcda0f1053ee9db217807225d0536 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5807288 Reviewed-by: Devlin Cronin <rdevlin.cronin@chromium.org> Commit-Queue: Tim <tjudkins@chromium.org> Cr-Commit-Position: refs/heads/main@{#1345745}
673 lines
20 KiB
Python
Executable File
673 lines
20 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright 2012 The Chromium Authors
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
import idl_schema
|
|
import unittest
|
|
|
|
from json_parse import OrderedDict
|
|
|
|
|
|
def getFunction(schema, name):
|
|
for item in schema['functions']:
|
|
if item['name'] == name:
|
|
return item
|
|
raise KeyError('Missing function %s' % name)
|
|
|
|
|
|
def getParams(schema, name):
|
|
function = getFunction(schema, name)
|
|
return function['parameters']
|
|
|
|
|
|
def getReturnsAsync(schema, name):
|
|
function = getFunction(schema, name)
|
|
return function.get('returns_async', False)
|
|
|
|
|
|
def getReturns(schema, name):
|
|
function = getFunction(schema, name)
|
|
return function['returns']
|
|
|
|
|
|
def getType(schema, id):
|
|
for item in schema['types']:
|
|
if item['id'] == id:
|
|
return item
|
|
|
|
|
|
class IdlSchemaTest(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
loaded = idl_schema.Load('test/idl_basics.idl')
|
|
self.assertEqual(1, len(loaded))
|
|
self.assertEqual('idl_basics', loaded[0]['namespace'])
|
|
self.idl_basics = loaded[0]
|
|
self.maxDiff = None
|
|
|
|
def testSimpleCallbacks(self):
|
|
schema = self.idl_basics
|
|
expected = {'name': 'cb', 'parameters': []}
|
|
self.assertEqual(expected, getReturnsAsync(schema, 'function4'))
|
|
|
|
expected = {'name': 'cb', 'parameters': [{'name': 'x', 'type': 'integer'}]}
|
|
self.assertEqual(expected, getReturnsAsync(schema, 'function5'))
|
|
|
|
expected = {
|
|
'name': 'cb',
|
|
'parameters': [{
|
|
'name': 'arg',
|
|
'$ref': 'MyType1'
|
|
}]
|
|
}
|
|
self.assertEqual(expected, getReturnsAsync(schema, 'function6'))
|
|
|
|
def testCallbackWithArrayArgument(self):
|
|
schema = self.idl_basics
|
|
expected = {
|
|
'name':
|
|
'cb',
|
|
'parameters': [{
|
|
'name': 'arg',
|
|
'type': 'array',
|
|
'items': {
|
|
'$ref': 'MyType2'
|
|
}
|
|
}]
|
|
}
|
|
self.assertEqual(expected, getReturnsAsync(schema, 'function12'))
|
|
|
|
def testArrayOfCallbacks(self):
|
|
schema = idl_schema.Load('test/idl_function_types.idl')[0]
|
|
expected = [{
|
|
'type': 'array',
|
|
'name': 'callbacks',
|
|
'items': {
|
|
'type': 'function',
|
|
'name': 'MyCallback',
|
|
'parameters': [{
|
|
'type': 'integer',
|
|
'name': 'x'
|
|
}]
|
|
}
|
|
}]
|
|
self.assertEqual(expected, getParams(schema, 'whatever'))
|
|
|
|
def testProperties(self):
|
|
self.assertEqual(
|
|
{
|
|
'x': {
|
|
'name': 'x',
|
|
'type': 'integer',
|
|
'description': 'This comment tests "double-quotes".'
|
|
},
|
|
'y': {
|
|
'name': 'y',
|
|
'type': 'string'
|
|
},
|
|
'z': {
|
|
'name': 'z',
|
|
'type': 'string'
|
|
},
|
|
'a': {
|
|
'name': 'a',
|
|
'type': 'string'
|
|
},
|
|
'b': {
|
|
'name': 'b',
|
|
'type': 'string'
|
|
},
|
|
'c': {
|
|
'name': 'c',
|
|
'type': 'string'
|
|
}
|
|
},
|
|
getType(self.idl_basics, 'MyType1')['properties'])
|
|
|
|
def testMemberOrdering(self):
|
|
self.assertEqual(['x', 'y', 'z', 'a', 'b', 'c'],
|
|
list(
|
|
getType(self.idl_basics,
|
|
'MyType1')['properties'].keys()))
|
|
|
|
def testEnum(self):
|
|
schema = self.idl_basics
|
|
expected = {
|
|
'enum': [{
|
|
'name': 'name1',
|
|
'description': 'comment1'
|
|
}, {
|
|
'name': 'name2'
|
|
}],
|
|
'description': 'Enum description',
|
|
'type': 'string',
|
|
'id': 'EnumType'
|
|
}
|
|
self.assertEqual(expected, getType(schema, expected['id']))
|
|
|
|
expected_params = [{'name': 'type', '$ref': 'EnumType'}]
|
|
expected_returns_async = {
|
|
'name': 'cb',
|
|
'parameters': [{
|
|
'name': 'type',
|
|
'$ref': 'EnumType'
|
|
}]
|
|
}
|
|
self.assertEqual(expected_params, getParams(schema, 'function13'))
|
|
self.assertEqual(expected_returns_async,
|
|
getReturnsAsync(schema, 'function13'))
|
|
|
|
expected = [{
|
|
'items': {
|
|
'$ref': 'EnumType'
|
|
},
|
|
'name': 'types',
|
|
'type': 'array'
|
|
}]
|
|
self.assertEqual(expected, getParams(schema, 'function14'))
|
|
|
|
def testScopedArguments(self):
|
|
schema = self.idl_basics
|
|
expected = [{'name': 'value', '$ref': 'idl_other_namespace.SomeType'}]
|
|
self.assertEqual(expected, getParams(schema, 'function20'))
|
|
|
|
expected = [{
|
|
'items': {
|
|
'$ref': 'idl_other_namespace.SomeType'
|
|
},
|
|
'name': 'values',
|
|
'type': 'array'
|
|
}]
|
|
self.assertEqual(expected, getParams(schema, 'function21'))
|
|
|
|
expected = [{
|
|
'name': 'value',
|
|
'$ref': 'idl_other_namespace.sub_namespace.AnotherType'
|
|
}]
|
|
self.assertEqual(expected, getParams(schema, 'function22'))
|
|
|
|
expected = [{
|
|
'items': {
|
|
'$ref': 'idl_other_namespace.sub_namespace.'
|
|
'AnotherType'
|
|
},
|
|
'name': 'values',
|
|
'type': 'array'
|
|
}]
|
|
self.assertEqual(expected, getParams(schema, 'function23'))
|
|
|
|
def testNoCompile(self):
|
|
schema = self.idl_basics
|
|
func = getFunction(schema, 'function15')
|
|
self.assertTrue(func is not None)
|
|
self.assertTrue(func['nocompile'])
|
|
|
|
def testNoDocOnEnum(self):
|
|
schema = self.idl_basics
|
|
enum_with_nodoc = getType(schema, 'EnumTypeWithNoDoc')
|
|
self.assertTrue(enum_with_nodoc is not None)
|
|
self.assertTrue(enum_with_nodoc['nodoc'])
|
|
|
|
def testNoDocOnEnumValue(self):
|
|
schema = self.idl_basics
|
|
expected = {
|
|
'enum': [{
|
|
'name': 'name1'
|
|
}, {
|
|
'name': 'name2',
|
|
'nodoc': True,
|
|
'description': 'comment2'
|
|
}, {
|
|
'name': 'name3',
|
|
'description': 'comment3'
|
|
}],
|
|
'type':
|
|
'string',
|
|
'id':
|
|
'EnumTypeWithNoDocValue',
|
|
'description':
|
|
''
|
|
}
|
|
self.assertEqual(expected, getType(schema, expected['id']))
|
|
|
|
def testReturnTypes(self):
|
|
schema = self.idl_basics
|
|
self.assertEqual({
|
|
'name': 'function24',
|
|
'type': 'integer'
|
|
}, getReturns(schema, 'function24'))
|
|
self.assertEqual({
|
|
'name': 'function25',
|
|
'$ref': 'MyType1',
|
|
'optional': True
|
|
}, getReturns(schema, 'function25'))
|
|
self.assertEqual(
|
|
{
|
|
'name': 'function26',
|
|
'type': 'array',
|
|
'items': {
|
|
'$ref': 'MyType1'
|
|
}
|
|
}, getReturns(schema, 'function26'))
|
|
self.assertEqual(
|
|
{
|
|
'name': 'function27',
|
|
'$ref': 'EnumType',
|
|
'optional': True
|
|
}, getReturns(schema, 'function27'))
|
|
self.assertEqual(
|
|
{
|
|
'name': 'function28',
|
|
'type': 'array',
|
|
'items': {
|
|
'$ref': 'EnumType'
|
|
}
|
|
}, getReturns(schema, 'function28'))
|
|
self.assertEqual(
|
|
{
|
|
'name': 'function29',
|
|
'$ref': 'idl_other_namespace.SomeType',
|
|
'optional': True
|
|
}, getReturns(schema, 'function29'))
|
|
self.assertEqual(
|
|
{
|
|
'name': 'function30',
|
|
'type': 'array',
|
|
'items': {
|
|
'$ref': 'idl_other_namespace.SomeType'
|
|
}
|
|
}, getReturns(schema, 'function30'))
|
|
|
|
def testIgnoresAdditionalPropertiesOnType(self):
|
|
self.assertTrue(
|
|
getType(self.idl_basics,
|
|
'IgnoreAdditionalPropertiesType')['ignoreAdditionalProperties'])
|
|
|
|
def testChromeOSPlatformsNamespace(self):
|
|
schema = idl_schema.Load('test/idl_namespace_chromeos.idl')[0]
|
|
self.assertEqual('idl_namespace_chromeos', schema['namespace'])
|
|
expected = ['chromeos']
|
|
self.assertEqual(expected, schema['platforms'])
|
|
|
|
def testAllPlatformsNamespace(self):
|
|
schema = idl_schema.Load('test/idl_namespace_all_platforms.idl')[0]
|
|
self.assertEqual('idl_namespace_all_platforms', schema['namespace'])
|
|
expected = ['chromeos', 'fuchsia', 'linux', 'mac', 'win']
|
|
self.assertEqual(expected, schema['platforms'])
|
|
|
|
def testNonSpecificPlatformsNamespace(self):
|
|
schema = idl_schema.Load('test/idl_namespace_non_specific_platforms.idl')[0]
|
|
self.assertEqual('idl_namespace_non_specific_platforms',
|
|
schema['namespace'])
|
|
expected = None
|
|
self.assertEqual(expected, schema['platforms'])
|
|
|
|
def testGenerateErrorMessages(self):
|
|
schema = idl_schema.Load('test/idl_generate_error_messages.idl')[0]
|
|
self.assertEqual('idl_generate_error_messages', schema['namespace'])
|
|
self.assertTrue(schema['compiler_options'].get('generate_error_messages',
|
|
False))
|
|
|
|
schema = idl_schema.Load('test/idl_basics.idl')[0]
|
|
self.assertEqual('idl_basics', schema['namespace'])
|
|
self.assertFalse(schema['compiler_options'].get('generate_error_messages',
|
|
False))
|
|
|
|
def testSpecificImplementNamespace(self):
|
|
schema = idl_schema.Load('test/idl_namespace_specific_implement.idl')[0]
|
|
self.assertEqual('idl_namespace_specific_implement', schema['namespace'])
|
|
expected = 'idl_namespace_specific_implement.idl'
|
|
self.assertEqual(expected, schema['compiler_options']['implemented_in'])
|
|
|
|
def testSpecificImplementOnChromeOSNamespace(self):
|
|
schema = idl_schema.Load(
|
|
'test/idl_namespace_specific_implement_chromeos.idl')[0]
|
|
self.assertEqual('idl_namespace_specific_implement_chromeos',
|
|
schema['namespace'])
|
|
expected_implemented_path = 'idl_namespace_specific_implement_chromeos.idl'
|
|
expected_platform = ['chromeos']
|
|
self.assertEqual(expected_implemented_path,
|
|
schema['compiler_options']['implemented_in'])
|
|
self.assertEqual(expected_platform, schema['platforms'])
|
|
|
|
def testCallbackComment(self):
|
|
schema = self.idl_basics
|
|
self.assertEqual('A comment on a callback.',
|
|
getReturnsAsync(schema, 'function16')['description'])
|
|
self.assertEqual(
|
|
'A parameter.',
|
|
getReturnsAsync(schema, 'function16')['parameters'][0]['description'])
|
|
self.assertEqual(
|
|
'Just a parameter comment, with no comment on the callback.',
|
|
getReturnsAsync(schema, 'function17')['parameters'][0]['description'])
|
|
self.assertEqual('Override callback comment.',
|
|
getReturnsAsync(schema, 'function18')['description'])
|
|
|
|
def testFunctionComment(self):
|
|
schema = self.idl_basics
|
|
func = getFunction(schema, 'function3')
|
|
self.assertEqual(('This comment should appear in the documentation, '
|
|
'despite occupying multiple lines.'), func['description'])
|
|
self.assertEqual([{
|
|
'description': ('So should this comment about the argument. '
|
|
'<em>HTML</em> is fine too.'),
|
|
'name':
|
|
'arg',
|
|
'$ref':
|
|
'MyType1'
|
|
}], func['parameters'])
|
|
func = getFunction(schema, 'function4')
|
|
self.assertEqual(
|
|
'<p>This tests if "double-quotes" are escaped correctly.</p>'
|
|
'<p>It also tests a comment with two newlines.</p>',
|
|
func['description'])
|
|
|
|
def testReservedWords(self):
|
|
schema = idl_schema.Load('test/idl_reserved_words.idl')[0]
|
|
|
|
foo_type = getType(schema, 'Foo')
|
|
self.assertEqual([{
|
|
'name': 'float'
|
|
}, {
|
|
'name': 'DOMString'
|
|
}], foo_type['enum'])
|
|
|
|
enum_type = getType(schema, 'enum')
|
|
self.assertEqual([{
|
|
'name': 'callback'
|
|
}, {
|
|
'name': 'namespace'
|
|
}], enum_type['enum'])
|
|
|
|
dictionary = getType(schema, 'dictionary')
|
|
self.assertEqual('integer', dictionary['properties']['long']['type'])
|
|
|
|
mytype = getType(schema, 'MyType')
|
|
self.assertEqual('string', mytype['properties']['interface']['type'])
|
|
|
|
params = getParams(schema, 'static')
|
|
self.assertEqual('Foo', params[0]['$ref'])
|
|
self.assertEqual('enum', params[1]['$ref'])
|
|
|
|
def testObjectTypes(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
|
|
foo_type = getType(schema, 'FooType')
|
|
self.assertEqual('object', foo_type['type'])
|
|
self.assertEqual('integer', foo_type['properties']['x']['type'])
|
|
self.assertEqual('object', foo_type['properties']['y']['type'])
|
|
self.assertEqual(
|
|
'any', foo_type['properties']['y']['additionalProperties']['type'])
|
|
self.assertEqual('object', foo_type['properties']['z']['type'])
|
|
self.assertEqual(
|
|
'any', foo_type['properties']['z']['additionalProperties']['type'])
|
|
self.assertEqual('Window', foo_type['properties']['z']['isInstanceOf'])
|
|
|
|
bar_type = getType(schema, 'BarType')
|
|
self.assertEqual('object', bar_type['type'])
|
|
self.assertEqual('any', bar_type['properties']['x']['type'])
|
|
|
|
def testObjectTypesInFunctions(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
|
|
params = getParams(schema, 'objectFunction1')
|
|
self.assertEqual('object', params[0]['type'])
|
|
self.assertEqual('any', params[0]['additionalProperties']['type'])
|
|
self.assertEqual('ImageData', params[0]['isInstanceOf'])
|
|
|
|
params = getParams(schema, 'objectFunction2')
|
|
self.assertEqual('any', params[0]['type'])
|
|
|
|
def testObjectTypesWithOptionalFields(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
|
|
baz_type = getType(schema, 'BazType')
|
|
self.assertEqual(True, baz_type['properties']['x']['optional'])
|
|
self.assertEqual('integer', baz_type['properties']['x']['type'])
|
|
self.assertEqual(True, baz_type['properties']['foo']['optional'])
|
|
self.assertEqual('FooType', baz_type['properties']['foo']['$ref'])
|
|
|
|
def testObjectTypesWithUnions(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
|
|
union_type = getType(schema, 'UnionType')
|
|
expected = {
|
|
'type': 'object',
|
|
'id': 'UnionType',
|
|
'properties': {
|
|
'x': {
|
|
'name': 'x',
|
|
'optional': True,
|
|
'choices': [
|
|
{
|
|
'type': 'integer'
|
|
},
|
|
{
|
|
'$ref': 'FooType'
|
|
},
|
|
]
|
|
},
|
|
'y': {
|
|
'name':
|
|
'y',
|
|
'choices': [{
|
|
'type': 'string'
|
|
}, {
|
|
'type': 'object',
|
|
'additionalProperties': {
|
|
'type': 'any'
|
|
}
|
|
}]
|
|
},
|
|
'z': {
|
|
'name':
|
|
'z',
|
|
'choices': [{
|
|
'type': 'object',
|
|
'isInstanceOf': 'ImageData',
|
|
'additionalProperties': {
|
|
'type': 'any'
|
|
}
|
|
}, {
|
|
'type': 'integer'
|
|
}]
|
|
}
|
|
},
|
|
}
|
|
|
|
self.assertEqual(expected, union_type)
|
|
|
|
def testUnionsWithModifiers(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
|
|
union_type = getType(schema, 'ModifiedUnionType')
|
|
expected = {
|
|
'type': 'object',
|
|
'id': 'ModifiedUnionType',
|
|
'properties': {
|
|
'x': {
|
|
'name': 'x',
|
|
'nodoc': True,
|
|
'choices': [{
|
|
'type': 'integer'
|
|
}, {
|
|
'type': 'string'
|
|
}]
|
|
}
|
|
}
|
|
}
|
|
|
|
self.assertEqual(expected, union_type)
|
|
|
|
def testSerializableFunctionType(self):
|
|
schema = idl_schema.Load('test/idl_object_types.idl')[0]
|
|
object_type = getType(schema, 'SerializableFunctionObject')
|
|
expected = {
|
|
'type': 'object',
|
|
'id': 'SerializableFunctionObject',
|
|
'properties': {
|
|
'func': {
|
|
'name': 'func',
|
|
'serializableFunction': True,
|
|
'type': 'function',
|
|
'parameters': []
|
|
}
|
|
}
|
|
}
|
|
self.assertEqual(expected, object_type)
|
|
|
|
def testUnionsWithFunctions(self):
|
|
schema = idl_schema.Load('test/idl_function_types.idl')[0]
|
|
|
|
union_params = getParams(schema, 'union_params')
|
|
expected = [{
|
|
'name': 'x',
|
|
'choices': [{
|
|
'type': 'integer'
|
|
}, {
|
|
'type': 'string'
|
|
}]
|
|
}]
|
|
|
|
self.assertEqual(expected, union_params)
|
|
|
|
def testUnionsWithCallbacks(self):
|
|
schema = idl_schema.Load('test/idl_function_types.idl')[0]
|
|
|
|
blah_params = getReturnsAsync(schema, 'blah')
|
|
expected = {
|
|
'name':
|
|
'callback',
|
|
'parameters': [{
|
|
'name': 'x',
|
|
'choices': [{
|
|
'type': 'integer'
|
|
}, {
|
|
'type': 'string'
|
|
}]
|
|
}]
|
|
}
|
|
|
|
badabish_params = getReturnsAsync(schema, 'badabish')
|
|
expected = {
|
|
'name':
|
|
'callback',
|
|
'parameters': [{
|
|
'name': 'x',
|
|
'optional': True,
|
|
'choices': [{
|
|
'type': 'integer'
|
|
}, {
|
|
'type': 'string'
|
|
}]
|
|
}]
|
|
}
|
|
|
|
self.assertEqual(expected, badabish_params)
|
|
|
|
def testFunctionWithoutPromiseSupport(self):
|
|
schema = idl_schema.Load('test/idl_function_types.idl')[0]
|
|
|
|
expected_params = []
|
|
expected_returns_async = {
|
|
'name': 'callback',
|
|
'parameters': [{
|
|
'name': 'x',
|
|
'type': 'integer'
|
|
}],
|
|
'does_not_support_promises': 'Test'
|
|
}
|
|
params = getParams(schema, 'non_promise_supporting')
|
|
returns_async = getReturnsAsync(schema, 'non_promise_supporting')
|
|
|
|
self.assertEqual(expected_params, params)
|
|
self.assertEqual(expected_returns_async, returns_async)
|
|
|
|
def testFunctionWithoutPromiseSupportAndParams(self):
|
|
schema = idl_schema.Load('test/idl_function_types.idl')[0]
|
|
|
|
expected_params = [{
|
|
'name': 'z',
|
|
'type': 'integer'
|
|
}, {
|
|
'name': 'y',
|
|
'choices': [{
|
|
'type': 'integer'
|
|
}, {
|
|
'type': 'string'
|
|
}]
|
|
}]
|
|
expected_returns_async = {
|
|
'name': 'callback',
|
|
'parameters': [{
|
|
'name': 'x',
|
|
'type': 'integer'
|
|
}],
|
|
'does_not_support_promises': 'Test'
|
|
}
|
|
params = getParams(schema, 'non_promise_supporting_with_params')
|
|
returns_async = getReturnsAsync(schema,
|
|
'non_promise_supporting_with_params')
|
|
|
|
self.assertEqual(expected_params, params)
|
|
self.assertEqual(expected_returns_async, returns_async)
|
|
|
|
def testProperties(self):
|
|
schema = idl_schema.Load('test/idl_properties.idl')[0]
|
|
self.assertEqual(
|
|
OrderedDict([
|
|
('first',
|
|
OrderedDict([
|
|
('description', 'Integer property.'),
|
|
('type', 'integer'),
|
|
('value', 42),
|
|
])),
|
|
('second',
|
|
OrderedDict([
|
|
('description', 'Double property.'),
|
|
('type', 'number'),
|
|
('value', 42.1),
|
|
])),
|
|
('third',
|
|
OrderedDict([
|
|
('description', 'String property.'),
|
|
('type', 'string'),
|
|
('value', 'hello world'),
|
|
])),
|
|
('fourth',
|
|
OrderedDict([
|
|
('description', 'Unvalued property.'),
|
|
('type', 'integer'),
|
|
])),
|
|
]), schema.get('properties'))
|
|
|
|
def testManifestKeys(self):
|
|
schema = self.idl_basics
|
|
# Test a smattering of the manifest key generation. We don't make this
|
|
# exhaustive so we don't have to update it each time we add a new key in the
|
|
# test file.
|
|
manifest_keys = schema.get('manifest_keys')
|
|
self.assertEqual(
|
|
manifest_keys['key_str'],
|
|
OrderedDict([('description', 'String manifest key.'),
|
|
('name', 'key_str'), ('type', 'string')]))
|
|
self.assertEqual(manifest_keys['key_ref'],
|
|
OrderedDict([('name', 'key_ref'), ('$ref', 'MyType2')])),
|
|
self.assertEqual(
|
|
manifest_keys['choice_with_arrays'],
|
|
OrderedDict([('name', 'choice_with_arrays'),
|
|
('$ref', 'ChoiceWithArraysType')])),
|
|
self.assertEqual(
|
|
manifest_keys['choice_with_optional'],
|
|
OrderedDict([('name', 'choice_with_optional'),
|
|
('$ref', 'ChoiceWithOptionalType')]))
|
|
|
|
def testNoManifestKeys(self):
|
|
schema = idl_schema.Load('test/idl_properties.idl')[0]
|
|
self.assertIsNone(schema.get('manifest_keys'))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|