def _LoadInterfaceFile(self, interface_name):
"""Loads an interface from the database.
Returns:
An IDLInterface instance or None if the interface is not found.
Args:
interface_name -- the name of the interface.
"""
file_name = self._FilePath(interface_name)
_logger.info('loading %s' % file_name)
if not os.path.exists(file_name):
return None
f = open(file_name, 'r')
content = f.read()
f.close()
# Parse file:
idl_file = idlnode.IDLFile(self._idlparser.parse(content), file_name)
if not idl_file.interfaces:
raise RuntimeError('No interface found in %s' % file_name)
elif len(idl_file.interfaces) > 1:
raise RuntimeError('Expected one interface in %s' % file_name)
interface = idl_file.interfaces[0]
self._all_interfaces[interface_name] = interface
return interface
def _run_test(self, syntax, content, expected):
"""Utility run tests and prints extra contextual information.
Args:
syntax -- IDL grammar to use (either idlparser.WEBKIT_SYNTAX,
WEBIDL_SYNTAX or FREMONTCUT_SYNTAX). If None, will run
multiple tests, each with a different syntax.
content -- input text for the parser.
expected -- expected parse result.
"""
if syntax is None:
self._run_test(idlparser.WEBIDL_SYNTAX, content, expected)
self._run_test(idlparser.WEBKIT_SYNTAX, content, expected)
self._run_test(idlparser.FREMONTCUT_SYNTAX, content, expected)
return
actual = None
error = None
ast = None
parseResult = None
try:
parser = idlparser.IDLParser(syntax)
ast = parser.parse(content)
node = idlnode.IDLFile(ast)
actual = node.to_dict() if node else None
except SyntaxError, e:
error = e
pass
def setUp(self):
self._working_dir = tempfile.mkdtemp()
self._output_dir = os.path.join(self._working_dir, 'output')
self._database_dir = os.path.join(self._working_dir, 'database')
self._auxiliary_dir = os.path.join(self._working_dir, 'auxiliary')
self.assertFalse(os.path.exists(self._database_dir))
# Create database and add one interface.
db = database.Database(self._database_dir)
os.mkdir(self._auxiliary_dir)
self.assertTrue(os.path.exists(self._database_dir))
content = """
module shapes {
@A1 @A2
interface Shape {
@A1 @A2 getter attribute int attr;
@A1 setter attribute int attr;
@A3 boolean op();
const long CONSTANT = 1;
getter attribute DOMString strAttr;
Shape create();
boolean compare(Shape s);
Rectangle createRectangle();
void addLine(lines::Line line);
void someDartType(File file);
void someUnidentifiedType(UnidentifiableType t);
};
};
module rectangles {
@A3
interface Rectangle : @A3 shapes::Shape {
void someTemplatedType(List<Shape> list);
};
};
module lines {
@A1
interface Line : shapes::Shape {
};
};
"""
parser = idlparser.IDLParser(idlparser.FREMONTCUT_SYNTAX)
ast = parser.parse(content)
idl_file = idlnode.IDLFile(ast)
for module in idl_file.modules:
module_name = module.id
for interface in module.interfaces:
db.AddInterface(interface)
db.Save()
self.assertTrue(self._InDatabase('Shape'))
self.assertTrue(self._InDatabase('Rectangle'))
self.assertTrue(self._InDatabase('Line'))
self._database = database.Database(self._database_dir)
self._generator = dartgenerator.DartGenerator(self._auxiliary_dir,
'../templates', 'test')
def _run_test(self, input_text, expected_text):
"""Parses input, renders it and compares the results"""
parser = idlparser.IDLParser(idlparser.FREMONTCUT_SYNTAX)
idl_file = idlnode.IDLFile(parser.parse(input_text))
output_text = idlrenderer.render(idl_file)
if output_text != expected_text:
msg = '''
EXPECTED:
%s
ACTUAL :
%s
''' % (expected_text, output_text)
self.fail(msg)
def _ParseInterface(self, content):
ast = self._idl_parser.parse(content)
return idlnode.IDLFile(ast).interfaces[0]
