def test_preprocess_file(self):
mock_node = mock.Mock()
file_ = pre_ast.File(mock_node)
mock_node.accept.return_value = 42
actual = self.preprocessing_visitor.preprocess(file_)
expected = pre_ast.File(42)
self.assertEqual(actual, expected)
def test_parse_with_empty_ifndef_block_and_endif_with_comment(self):
source = """
#ifndef _SOMETHING_H
#endif /* _SOMETHING_H */
"""
actual = self.parser.parse(source)
expected = pre_ast.File(
pre_ast.CompositeBlock([
pre_ast.If([
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='!',
arguments=[
c_ast.CFunctionCall(
function_name='defined',
arguments=[
c_ast.CVariable('_SOMETHING_H')
]),
],
),
content=pre_ast.CompositeBlock([]),
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_with_empty_ifndef_header_guard(self):
source = """
#ifndef _SOMETHING_H
#define _SOMETHING_H
#endif
"""
actual = self.parser.parse(source)
expected = pre_ast.File(
pre_ast.CompositeBlock([
pre_ast.If([
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='!',
arguments=[
c_ast.CFunctionCall(
function_name='defined',
arguments=[
c_ast.CVariable('_SOMETHING_H')
]),
],
),
content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='_SOMETHING_H',
replacement=None,
string_replacement='',
),
]),
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_with_empty_if_elif_and_else_blocks(self):
source = """
#if CONFIG_SOMETHING
#elif defined(CONFIG_SOMETHING_ELSE)
#else
#endif
"""
actual = self.parser.parse(source)
expected = pre_ast.File(
pre_ast.CompositeBlock([
pre_ast.If(
conditional_blocks=[
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CVariable(
name='CONFIG_SOMETHING', ),
content=pre_ast.CompositeBlock([]),
),
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='defined',
arguments=[
c_ast.CVariable('CONFIG_SOMETHING_ELSE'),
],
),
content=pre_ast.CompositeBlock([]),
)
],
else_content=pre_ast.CompositeBlock([]),
),
]), )
self.assertEqual(actual, expected)
def test_parse_with_empty_if_and_elif_blocks_and_expressions(self):
source = """
#if CONFIG_SOMETHING == 32
#elif CONFIG_SOMETHING == 64
#endif
"""
actual = self.parser.parse(source)
expected = pre_ast.File(
pre_ast.CompositeBlock([
pre_ast.If(conditional_blocks=[
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='==',
arguments=[
c_ast.CVariable('CONFIG_SOMETHING'),
c_ast.CNumber(32),
],
),
content=pre_ast.CompositeBlock([]),
),
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='==',
arguments=[
c_ast.CVariable('CONFIG_SOMETHING'),
c_ast.CNumber(64),
],
),
content=pre_ast.CompositeBlock([]),
),
], ),
]), )
self.assertEqual(actual, expected)
def test_parse_error(self):
source = '#error foo bar 42 baz'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Error('foo bar 42 baz'),
]), )
self.assertEqual(actual, expected)
def test_collect_includes_with_file(self):
mock_node = mock.MagicMock()
node = pre_ast.File(mock_node)
mock_node.accept.return_value = 42
actual = self.include_collector.collect_includes(node)
expected = 42
self.assertEqual(actual, expected)
def test_parse_text_block(self):
source = 'int x;'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.TextBlock('int x;'),
]), )
self.assertEqual(actual, expected)
def test_parse_cpp_style_inside_text_block(self):
source = '\n'.join(['foo // bar', 'baz'])
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.TextBlock('foo \nbaz'),
]), )
self.assertEqual(actual, expected)
def test_parse_undef(self):
source = '#undef foo'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Undef('foo'),
]))
self.assertEqual(actual, expected)
def test_to_string_with_file(self):
mock_node = mock.MagicMock()
node = pre_ast.File(mock_node)
mock_node.accept.side_effect = (lambda visitor, parts: parts.extend(
('foo', 'bar', '42')))
actual = self.to_string_visitor.to_string(node)
expected = 'foo bar 42'
self.assertEqual(actual, expected)
def test_parse_pragma_with_string_argument(self):
source = '#pragma "-foo"'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock(
[pre_ast.Pragma([
pre_ast.PragmaArgument('"-foo"'),
])]))
self.assertEqual(actual, expected)
def test_resolve_with_file(self):
mock_node = mock.MagicMock()
node = pre_ast.File(mock_node)
self.include_linking_visitor.resolve(node, self.files)
mock_node.accept.assert_called_once_with(
self.include_linking_visitor,
self.files,
)
def test_parse_include_with_double_quotes(self):
source = '#include "some/path/to/file_2.h"'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Include(
path='some/path/to/file_2.h',
quotes_type=pre_ast.Include.QuotesType.DOUBLE_QUOTES,
)
]))
self.assertEqual(actual, expected)
def test_parse_include_with_angle_brackets(self):
source = '# include <some/path/to/file_1.h>'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Include(
path='some/path/to/file_1.h',
quotes_type=pre_ast.Include.QuotesType.ANGLE_BRACKETS,
)
]))
self.assertEqual(actual, expected)
def test_parse_define_string(self):
source = '#define foo "bar"'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='foo',
replacement=c_ast.CLiteral('"bar"'),
string_replacement=' "bar"',
),
]), )
self.assertEqual(actual, expected)
def test_parse_define_object_like_as_numeric_constant_with_comment(self):
source = '#define foo 42 /* bar */'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='foo',
replacement=c_ast.CNumber(42),
string_replacement=' 42 ',
),
]), )
self.assertEqual(actual, expected)
def test_parse_define_object_like(self):
source = '#define foo bar'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='foo',
replacement=c_ast.CVariable('bar'),
string_replacement=' bar',
),
]), )
self.assertEqual(actual, expected)
def test_parse_pragma_with_three_simple_arguments(self):
source = '#pragma foo bar baz'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument('foo'),
pre_ast.PragmaArgument('bar'),
pre_ast.PragmaArgument('baz'),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_pragma_with_argument_with_empty_arguments_list(self):
source = '#pragma foo()'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument(
name='foo',
arguments=[],
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_define_empty_funcion_like(self):
source = '#define foo()'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineFunctionLike(
name='foo',
arguments=[],
replacement=None,
string_replacement='',
),
]))
self.assertEqual(actual, expected)
def test_parse_define_funcion_like_without_arguments(self):
source = '#define foo() bar'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineFunctionLike(
name='foo',
arguments=[],
replacement=c_ast.CVariable('bar'),
string_replacement=' bar',
),
]))
self.assertEqual(actual, expected)
def test_parse_pragma_with_argument_with_value_assigned(self):
source = '#pragma foo=bar'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument(
name='foo',
value=c_ast.CVariable('bar'),
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_pragma_and_text_block(self):
source = '\n'.join((
'#pragma foo bar',
'int x;',
))
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument('foo'),
pre_ast.PragmaArgument('bar'),
]),
pre_ast.TextBlock('int x;'),
]), )
self.assertEqual(actual, expected)
def test_parse_pragma_with_argument_with_natural_number_argument(self):
source = '#pragma foo(42)'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument(
name='foo',
arguments=[
c_ast.CNumber(42),
],
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_pragma_with_argument_with_arguments(self):
source = '#pragma foo(bar, baz)'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.Pragma([
pre_ast.PragmaArgument(
name='foo',
arguments=[
c_ast.CVariable('bar'),
c_ast.CVariable('baz'),
],
),
]),
]), )
self.assertEqual(actual, expected)
def test_parse_define_object_like_with_parentheses_expression(self):
source = '#define foo (bar)'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='foo',
replacement=c_ast.CNestedExpression(
opener='(',
content=c_ast.CVariable('bar'),
closer=')',
),
string_replacement=' (bar)',
),
]), )
self.assertEqual(actual, expected)
def test_parse_with_top_level_if_elif_and_else_blocks(self):
source = '\n'.join((
'int a;',
'#if CONFIG_SOMETHING',
'struct s {',
' int x;',
'} y;',
'#elif defined(CONFIG_SOMETHING_ELSE)',
'struct s t, u;',
'#else',
'int z;',
'#endif',
'int b;',
))
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.TextBlock('int a;'),
pre_ast.If(
conditional_blocks=[
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CVariable(
name='CONFIG_SOMETHING', ),
content=pre_ast.CompositeBlock([
pre_ast.TextBlock(
'\n'.join((
'struct s {',
' int x;',
'} y;',
)), ),
]),
),
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CFunctionCall(
function_name='defined',
arguments=[
c_ast.CVariable('CONFIG_SOMETHING_ELSE'),
],
),
content=pre_ast.CompositeBlock(
[pre_ast.TextBlock('struct s t, u;')]),
),
],
else_content=pre_ast.CompositeBlock(
[pre_ast.TextBlock('int z;')]),
),
pre_ast.TextBlock('int b;'),
]), )
self.assertEqual(actual, expected)
def test_parse_if_with_comments(self):
source = """
#if 0 /* foo bar */
/* 42 */
#endif
"""
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.If(conditional_blocks=[
pre_ast.ConditionalBlock(
conditional_expression=c_ast.CNumber(0),
content=pre_ast.CompositeBlock([]),
),
], ),
]), )
self.assertEqual(actual, expected)
def test_parse_define_object_like_as_function_call(self):
source = '#define foo bar(x)'
actual = self.parser.parse(source)
expected = pre_ast.File(content=pre_ast.CompositeBlock([
pre_ast.DefineObjectLike(
name='foo',
replacement=c_ast.CFunctionCall(
function_name='bar',
arguments=[
c_ast.CVariable('x'),
],
),
string_replacement=' bar(x)',
),
]), )
self.assertEqual(actual, expected)
