def testInvalidMethods(self):
"""Tests that invalid method declarations are correctly detected."""
# No trailing commas.
source1 = """\
interface MyInterface {
MyMethod(string a,);
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '\)':\n"
r" *MyMethod\(string a,\);$"):
parser.Parse(source1, "my_file.mojom")
# No leading commas.
source2 = """\
interface MyInterface {
MyMethod(, string a);
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected ',':\n"
r" *MyMethod\(, string a\);$"):
parser.Parse(source2, "my_file.mojom")
def testValidAssociativeArrays(self):
"""Tests that we can parse valid associative array structures."""
source1 = "struct MyStruct { map<string, uint8> data; };"
expected1 = ast.Mojom(None, ast.ImportList(), [
ast.Struct(
'MyStruct', None,
ast.StructBody(
[ast.StructField('data', None, 'uint8{string}', None)]))
])
self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
source2 = "interface MyInterface { MyMethod(map<string, uint8> a); };"
expected2 = ast.Mojom(None, ast.ImportList(), [
ast.Interface(
'MyInterface', None,
ast.InterfaceBody(
ast.Method(
'MyMethod', None,
ast.ParameterList(
ast.Parameter('a', None, 'uint8{string}')), None)))
])
self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
source3 = "struct MyStruct { map<string, array<uint8>> data; };"
expected3 = ast.Mojom(None, ast.ImportList(), [
ast.Struct(
'MyStruct', None,
ast.StructBody(
[ast.StructField('data', None, 'uint8[]{string}', None)]))
])
self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
def testInvalidNullableTypes(self):
"""Tests that invalid nullable types are correctly detected."""
source1 = """\
struct MyStruct {
string?? a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '\?':\n"
r" *string\?\? a;$"):
parser.Parse(source1, "my_file.mojom")
source2 = """\
struct MyStruct {
handle?<data_pipe_consumer> a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '<':\n"
r" *handle\?<data_pipe_consumer> a;$"):
parser.Parse(source2, "my_file.mojom")
source3 = """\
struct MyStruct {
some_interface?& a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '&':\n"
r" *some_interface\?& a;$"):
parser.Parse(source3, "my_file.mojom")
def testInvalidAttributes(self):
"""Tests that invalid attributes and attribute lists are correctly
detected."""
# Trailing commas not allowed.
source1 = "[MyAttribute=MyName,] struct MyStruct {};"
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:1: Error: Unexpected '\]':\n"
r"\[MyAttribute=MyName,\] struct MyStruct {};$"):
parser.Parse(source1, "my_file.mojom")
# Missing value.
source2 = "[MyAttribute=] struct MyStruct {};"
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:1: Error: Unexpected '\]':\n"
r"\[MyAttribute=\] struct MyStruct {};$"):
parser.Parse(source2, "my_file.mojom")
# Missing key.
source3 = "[=MyName] struct MyStruct {};"
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:1: Error: Unexpected '=':\n"
r"\[=MyName\] struct MyStruct {};$"):
parser.Parse(source3, "my_file.mojom")
def testValidImports(self):
"""Tests parsing import statements."""
# One import (no module statement).
source1 = "import \"somedir/my.mojom\";"
expected1 = ast.Mojom(
None,
ast.ImportList(ast.Import("somedir/my.mojom")),
[])
self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
# Two imports (no module statement).
source2 = """\
import "somedir/my1.mojom";
import "somedir/my2.mojom";
"""
expected2 = ast.Mojom(
None,
ast.ImportList([ast.Import("somedir/my1.mojom"),
ast.Import("somedir/my2.mojom")]),
[])
self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
# Imports with module statement.
source3 = """\
module my_module;
import "somedir/my1.mojom";
import "somedir/my2.mojom";
"""
expected3 = ast.Mojom(
ast.Module(('IDENTIFIER', 'my_module'), None),
ast.ImportList([ast.Import("somedir/my1.mojom"),
ast.Import("somedir/my2.mojom")]),
[])
self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
def testInvalidAssociatedKinds(self):
"""Tests that invalid associated interfaces and requests are correctly
detected."""
source1 = """\
struct MyStruct {
associated associated SomeInterface a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'associated':\n"
r" *associated associated SomeInterface a;$"):
parser.Parse(source1, "my_file.mojom")
source2 = """\
struct MyStruct {
associated handle a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'handle':\n"
r" *associated handle a;$"):
parser.Parse(source2, "my_file.mojom")
source3 = """\
struct MyStruct {
associated? MyInterface& a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '\?':\n"
r" *associated\? MyInterface& a;$"):
parser.Parse(source3, "my_file.mojom")
def testValidAttributes(self):
"""Tests parsing attributes (and attribute lists)."""
# Note: We use structs because they have (optional) attribute lists.
# Empty attribute list.
source1 = "[] struct MyStruct {};"
expected1 = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct('MyStruct', ast.AttributeList(), ast.StructBody())])
self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
# One-element attribute list, with name value.
source2 = "[MyAttribute=MyName] struct MyStruct {};"
expected2 = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
ast.AttributeList(ast.Attribute("MyAttribute", "MyName")),
ast.StructBody())])
self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
# Two-element attribute list, with one string value and one integer value.
source3 = "[MyAttribute1 = \"hello\", MyAttribute2 = 5] struct MyStruct {};"
expected3 = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
ast.AttributeList([ast.Attribute("MyAttribute1", "hello"),
ast.Attribute("MyAttribute2", 5)]),
ast.StructBody())])
self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
def testMissingModuleName(self):
"""Tests an (invalid) .mojom with a missing module name."""
source1 = """\
// Missing module name.
module ;
struct MyStruct {
int32 a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected ';':\n *module ;$"):
parser.Parse(source1, "my_file.mojom")
# Another similar case, but make sure that line-number tracking/reporting
# is correct.
source2 = """\
module
// This line intentionally left unblank.
struct MyStruct {
int32 a;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:4: Error: Unexpected 'struct':\n"
r" *struct MyStruct {$"):
parser.Parse(source2, "my_file.mojom")
def testInvalidEnumInitializers(self):
"""Tests that invalid enum initializers are correctly detected."""
# No values.
source1 = """\
enum MyEnum {
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected '}':\n"
r" *};$"):
parser.Parse(source1, "my_file.mojom")
# Floating point value.
source2 = "enum MyEnum { VALUE = 0.123 };"
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:1: Error: Unexpected '0\.123':\n"
r"enum MyEnum { VALUE = 0\.123 };$"):
parser.Parse(source2, "my_file.mojom")
# Boolean value.
source2 = "enum MyEnum { VALUE = true };"
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:1: Error: Unexpected 'true':\n"
r"enum MyEnum { VALUE = true };$"):
parser.Parse(source2, "my_file.mojom")
def testCommentLineNumbers(self):
"""Tests that line numbers are correctly tracked when comments are
present."""
source1 = """\
// Isolated C++-style comments.
// Foo.
asdf1
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:4: Error: Unexpected 'asdf1':\n *asdf1$"):
parser.Parse(source1, "my_file.mojom")
source2 = """\
// Consecutive C++-style comments.
// Foo.
// Bar.
struct Yada { // Baz.
// Quux.
int32 x;
};
asdf2
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:10: Error: Unexpected 'asdf2':\n *asdf2$"):
parser.Parse(source2, "my_file.mojom")
source3 = """\
/* Single-line C-style comments. */
/* Foobar. */
/* Baz. */
asdf3
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:5: Error: Unexpected 'asdf3':\n *asdf3$"):
parser.Parse(source3, "my_file.mojom")
source4 = """\
/* Multi-line C-style comments.
*/
/*
Foo.
Bar.
*/
/* Baz
Quux. */
asdf4
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:10: Error: Unexpected 'asdf4':\n *asdf4$"):
parser.Parse(source4, "my_file.mojom")
def testInvalidFixedArraySize(self):
"""Tests that invalid fixed array bounds are correctly detected."""
source1 = """\
struct MyStruct {
array<int32, 0> zero_size_array;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Fixed array size 0 invalid:\n"
r" *array<int32, 0> zero_size_array;$"):
parser.Parse(source1, "my_file.mojom")
source2 = """\
struct MyStruct {
array<int32, 999999999999> too_big_array;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Fixed array size 999999999999 invalid:\n"
r" *array<int32, 999999999999> too_big_array;$"):
parser.Parse(source2, "my_file.mojom")
source3 = """\
struct MyStruct {
array<int32, abcdefg> not_a_number;
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'abcdefg':\n"
r" *array<int32, abcdefg> not_a_number;"):
parser.Parse(source3, "my_file.mojom")
def testValidMethod(self):
"""Tests parsing method declarations."""
source1 = "interface MyInterface { MyMethod(int32 a); };"
expected1 = ast.Mojom(None, ast.ImportList(), [
ast.Interface(
'MyInterface', None,
ast.InterfaceBody(
ast.Method(
'MyMethod', None,
ast.ParameterList(ast.Parameter('a', None, 'int32')),
None)))
])
self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
source2 = """\
interface MyInterface {
MyMethod1@0(int32 a@0, int64 b@1);
MyMethod2@1() => ();
};
"""
expected2 = ast.Mojom(None, ast.ImportList(), [
ast.Interface(
'MyInterface', None,
ast.InterfaceBody([
ast.Method(
'MyMethod1', ast.Ordinal(0),
ast.ParameterList([
ast.Parameter('a', ast.Ordinal(0), 'int32'),
ast.Parameter('b', ast.Ordinal(1), 'int64')
]), None),
ast.Method('MyMethod2', ast.Ordinal(1),
ast.ParameterList(), ast.ParameterList())
]))
])
self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
source3 = """\
interface MyInterface {
MyMethod(string a) => (int32 a, bool b);
};
"""
expected3 = ast.Mojom(None, ast.ImportList(), [
ast.Interface(
'MyInterface', None,
ast.InterfaceBody(
ast.Method(
'MyMethod', None,
ast.ParameterList(ast.Parameter('a', None, 'string')),
ast.ParameterList([
ast.Parameter('a', None, 'int32'),
ast.Parameter('b', None, 'bool')
]))))
])
self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
def parseMojom(mojom, file_overrides, override_modules):
if mojom in unmodified_modules or mojom in override_modules:
return
contents = file_overrides.get(mojom)
if contents:
modules = override_modules
else:
modules = unmodified_modules
with io.open(os.path.join(root, mojom), encoding='utf-8') as f:
contents = f.read()
try:
ast = parser.Parse(contents, mojom)
except Exception as e:
six.reraise(
ParseError,
'encountered exception {0} while parsing {1}'.format(e, mojom),
sys.exc_info()[2])
for imp in ast.import_list:
parseMojom(imp.import_filename, file_overrides, override_modules)
# Now that the transitive set of dependencies has been imported and parsed
# above, translate each mojom AST into a Module so that all types are fully
# defined and can be inspected.
all_modules = {}
all_modules.update(unmodified_modules)
all_modules.update(override_modules)
modules[mojom] = translate.OrderedModule(ast, mojom, all_modules)
def testEnumInitializers(self):
"""Tests an enum with simple initialized values."""
source = """\
module my_module {
enum MyEnum {
MY_ENUM_NEG1 = -1,
MY_ENUM_ZERO = 0,
MY_ENUM_1 = +1,
MY_ENUM_2,
};
} // my_module
"""
expected = \
[('MODULE',
'my_module',
None,
[('ENUM',
'MyEnum',
[('ENUM_FIELD', 'MY_ENUM_NEG1', '-1'),
('ENUM_FIELD', 'MY_ENUM_ZERO', '0'),
('ENUM_FIELD', 'MY_ENUM_1', '+1'),
('ENUM_FIELD', 'MY_ENUM_2', None)])])]
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testEnums(self):
"""Tests that enum statements are correctly parsed."""
source = """\
module my_module {
enum MyEnum1 { VALUE1, VALUE2 }; // No trailing comma.
enum MyEnum2 {
VALUE1 = -1,
VALUE2 = 0,
VALUE3 = + 987, // Check that space is allowed.
VALUE4 = 0xAF12,
VALUE5 = -0x09bcd,
VALUE6 = VALUE5,
VALUE7, // Leave trailing comma.
};
} // my_module
"""
expected = ast.Mojom(
ast.Module(('IDENTIFIER', 'my_module'), None),
ast.ImportList(),
[ast.Enum(
'MyEnum1',
ast.EnumValueList([ast.EnumValue('VALUE1', None),
ast.EnumValue('VALUE2', None)])),
ast.Enum(
'MyEnum2',
ast.EnumValueList([ast.EnumValue('VALUE1', '-1'),
ast.EnumValue('VALUE2', '0'),
ast.EnumValue('VALUE3', '+987'),
ast.EnumValue('VALUE4', '0xAF12'),
ast.EnumValue('VALUE5', '-0x09bcd'),
ast.EnumValue('VALUE6', ('IDENTIFIER',
'VALUE5')),
ast.EnumValue('VALUE7', None)]))])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidStructDefinitions(self):
"""Tests all types of definitions that can occur in a struct."""
source = """\
struct MyStruct {
enum MyEnum { VALUE };
const double kMyConst = 1.23;
int32 a;
SomeOtherStruct b; // Invalidity detected at another stage.
};
"""
expected = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
None,
ast.StructBody(
[ast.Enum('MyEnum',
None,
ast.EnumValueList(
ast.EnumValue('VALUE', None, None))),
ast.Const('kMyConst', 'double', '1.23'),
ast.StructField('a', None, None, 'int32', None),
ast.StructField('b', None, None, 'SomeOtherStruct', None)]))])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidDefaultValues(self):
"""Tests default values that are valid (to the parser)."""
source = """\
struct MyStruct {
int16 a0 = 0;
uint16 a1 = 0x0;
uint16 a2 = 0x00;
uint16 a3 = 0x01;
uint16 a4 = 0xcd;
int32 a5 = 12345;
int64 a6 = -12345;
int64 a7 = +12345;
uint32 a8 = 0x12cd3;
uint32 a9 = -0x12cD3;
uint32 a10 = +0x12CD3;
bool a11 = true;
bool a12 = false;
float a13 = 1.2345;
float a14 = -1.2345;
float a15 = +1.2345;
float a16 = 123.;
float a17 = .123;
double a18 = 1.23E10;
double a19 = 1.E-10;
double a20 = .5E+10;
double a21 = -1.23E10;
double a22 = +.123E10;
};
"""
expected = ast.Mojom(None, ast.ImportList(), [
ast.Struct(
'MyStruct', None,
ast.StructBody([
ast.StructField('a0', None, 'int16', '0'),
ast.StructField('a1', None, 'uint16', '0x0'),
ast.StructField('a2', None, 'uint16', '0x00'),
ast.StructField('a3', None, 'uint16', '0x01'),
ast.StructField('a4', None, 'uint16', '0xcd'),
ast.StructField('a5', None, 'int32', '12345'),
ast.StructField('a6', None, 'int64', '-12345'),
ast.StructField('a7', None, 'int64', '+12345'),
ast.StructField('a8', None, 'uint32', '0x12cd3'),
ast.StructField('a9', None, 'uint32', '-0x12cD3'),
ast.StructField('a10', None, 'uint32', '+0x12CD3'),
ast.StructField('a11', None, 'bool', 'true'),
ast.StructField('a12', None, 'bool', 'false'),
ast.StructField('a13', None, 'float', '1.2345'),
ast.StructField('a14', None, 'float', '-1.2345'),
ast.StructField('a15', None, 'float', '+1.2345'),
ast.StructField('a16', None, 'float', '123.'),
ast.StructField('a17', None, 'float', '.123'),
ast.StructField('a18', None, 'double', '1.23E10'),
ast.StructField('a19', None, 'double', '1.E-10'),
ast.StructField('a20', None, 'double', '.5E+10'),
ast.StructField('a21', None, 'double', '-1.23E10'),
ast.StructField('a22', None, 'double', '+.123E10')
]))
])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testSourceWithCrLfs(self):
"""Tests a .mojom source with CR-LFs instead of LFs."""
source = "// This is a comment.\r\n\r\nmodule my_module;\r\n"
expected = ast.Mojom(ast.Module(('IDENTIFIER', 'my_module'), None),
ast.ImportList(), [])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidHandleTypes(self):
"""Tests (valid) handle types."""
source = """\
struct MyStruct {
handle a;
handle<data_pipe_consumer> b;
handle <data_pipe_producer> c;
handle < message_pipe > d;
handle
< shared_buffer
> e;
};
"""
expected = \
[('MODULE',
'',
None,
[('STRUCT',
'MyStruct',
None,
[('FIELD', 'handle', 'a', ast.Ordinal(None), None),
('FIELD', 'handle<data_pipe_consumer>', 'b', ast.Ordinal(None), None),
('FIELD', 'handle<data_pipe_producer>', 'c', ast.Ordinal(None), None),
('FIELD', 'handle<message_pipe>', 'd', ast.Ordinal(None), None),
('FIELD', 'handle<shared_buffer>', 'e', ast.Ordinal(None), None)])])]
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testSimpleOrdinals(self):
"""Tests that (valid) ordinal values are scanned correctly."""
source = """\
module my_module {
// This isn't actually valid .mojom, but the problem (missing ordinals) should
// be handled at a different level.
struct MyStruct {
int32 a0 @0;
int32 a1 @1;
int32 a2 @2;
int32 a9 @9;
int32 a10 @10;
int32 a11 @11;
int32 a29 @29;
int32 a1234567890 @1234567890;
};
} // module my_module
"""
expected = \
[('MODULE',
'my_module',
[('STRUCT',
'MyStruct',
None,
[('FIELD', 'int32', 'a0', ast.Ordinal(0), None),
('FIELD', 'int32', 'a1', ast.Ordinal(1), None),
('FIELD', 'int32', 'a2', ast.Ordinal(2), None),
('FIELD', 'int32', 'a9', ast.Ordinal(9), None),
('FIELD', 'int32', 'a10', ast.Ordinal(10), None),
('FIELD', 'int32', 'a11', ast.Ordinal(11), None),
('FIELD', 'int32', 'a29', ast.Ordinal(29), None),
('FIELD', 'int32', 'a1234567890', ast.Ordinal(1234567890), None)])])]
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidInterfaceDefinitions(self):
"""Tests all types of definitions that can occur in an interface."""
source = """\
interface MyInterface {
enum MyEnum { VALUE };
const int32 kMyConst = 123;
MyMethod(int32 x) => (MyEnum y);
};
"""
expected = ast.Mojom(
None,
ast.ImportList(),
[ast.Interface(
'MyInterface',
None,
ast.InterfaceBody(
[ast.Enum('MyEnum',
None,
ast.EnumValueList(
ast.EnumValue('VALUE', None, None))),
ast.Const('kMyConst', 'int32', '123'),
ast.Method(
'MyMethod',
None,
None,
ast.ParameterList(ast.Parameter('x', None, None, 'int32')),
ast.ParameterList(ast.Parameter('y', None, None,
'MyEnum')))]))])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidFixedSizeArray(self):
"""Tests parsing a fixed size array."""
source = """\
struct MyStruct {
array<int32> normal_array;
array<int32, 1> fixed_size_array_one_entry;
array<int32, 10> fixed_size_array_ten_entries;
array<array<array<int32, 1>>, 2> nested_arrays;
};
"""
expected = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
None,
ast.StructBody(
[ast.StructField('normal_array', None, None, 'int32[]', None),
ast.StructField('fixed_size_array_one_entry', None, None,
'int32[1]', None),
ast.StructField('fixed_size_array_ten_entries', None, None,
'int32[10]', None),
ast.StructField('nested_arrays', None, None,
'int32[1][][2]', None)]))])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidHandleTypes(self):
"""Tests (valid) handle types."""
source = """\
struct MyStruct {
handle a;
handle<data_pipe_consumer> b;
handle <data_pipe_producer> c;
handle < message_pipe > d;
handle
< shared_buffer
> e;
};
"""
expected = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
None,
ast.StructBody(
[ast.StructField('a', None, None, 'handle', None),
ast.StructField('b', None, None, 'handle<data_pipe_consumer>',
None),
ast.StructField('c', None, None, 'handle<data_pipe_producer>',
None),
ast.StructField('d', None, None, 'handle<message_pipe>', None),
ast.StructField('e', None, None, 'handle<shared_buffer>',
None)]))])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidAssociatedKinds(self):
"""Tests parsing associated interfaces and requests."""
source1 = """\
struct MyStruct {
associated MyInterface a;
associated MyInterface& b;
associated MyInterface? c;
associated MyInterface&? d;
};
"""
expected1 = ast.Mojom(
None,
ast.ImportList(),
[ast.Struct(
'MyStruct',
None,
ast.StructBody(
[ast.StructField('a', None, None,'asso<MyInterface>', None),
ast.StructField('b', None, None,'asso<MyInterface&>', None),
ast.StructField('c', None, None,'asso<MyInterface>?', None),
ast.StructField('d', None, None,'asso<MyInterface&>?',
None)]))])
self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
source2 = """\
interface MyInterface {
MyMethod(associated A a) =>(associated B& b);
};"""
expected2 = ast.Mojom(
None,
ast.ImportList(),
[ast.Interface(
'MyInterface',
None,
ast.InterfaceBody(
ast.Method(
'MyMethod',
None,
None,
ast.ParameterList(
ast.Parameter('a', None, None, 'asso<A>')),
ast.ParameterList(
ast.Parameter('b', None, None, 'asso<B&>')))))])
self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
def testTrivialValidSource(self):
"""Tests a trivial, but valid, .mojom source."""
source = """\
// This is a comment.
module my_module {
}
"""
self.assertEquals(parser.Parse(source, "my_file.mojom"),
[("MODULE", "my_module", None, None)])
def testInvalidInterfaceDefinitions(self):
"""Tests that definitions that aren't allowed in an interface are correctly
detected."""
source1 = """\
interface MyInterface {
struct MyStruct {
int32 a;
};
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'struct':\n"
r" *struct MyStruct {$"):
parser.Parse(source1, "my_file.mojom")
source2 = """\
interface MyInterface {
interface MyInnerInterface {
MyMethod(int32 x);
};
};
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'interface':\n"
r" *interface MyInnerInterface {$"):
parser.Parse(source2, "my_file.mojom")
source3 = """\
interface MyInterface {
int32 my_field;
};
"""
# The parser thinks that "int32" is a plausible name for a method, so it's
# "my_field" that gives it away.
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom:2: Error: Unexpected 'my_field':\n"
r" *int32 my_field;$"):
parser.Parse(source3, "my_file.mojom")
def testMultipleEnableIfs(self):
source = """
enum Foo {
[EnableIf=red,EnableIf=yellow]
kBarValue = 5,
};
"""
definition = parser.Parse(source, "my_file.mojom")
self.assertRaises(conditional_features.EnableIfError,
conditional_features.RemoveDisabledDefinitions,
definition, ENABLED_FEATURES)
def testUnexpectedEOF(self):
"""Tests a "truncated" .mojom source."""
source = """\
// This is a comment.
module my_module {
"""
with self.assertRaisesRegexp(
parser.ParseError,
r"^my_file\.mojom: Error: Unexpected end of file$"):
parser.Parse(source, "my_file.mojom")
def testTrivialValidSource(self):
"""Tests a trivial, but valid, .mojom source."""
source = """\
// This is a comment.
module my_module;
"""
expected = ast.Mojom(ast.Module(('IDENTIFIER', 'my_module'), None),
ast.ImportList(), [])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
def testValidNestedArray(self):
"""Tests parsing a nested array."""
source = "struct MyStruct { array<array<int32>> nested_array; };"
expected = ast.Mojom(None, ast.ImportList(), [
ast.Struct(
'MyStruct', None,
ast.StructBody(
ast.StructField('nested_array', None, 'int32[][]', None)))
])
self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
