"""Unit tests for addons/cppcheckdata.py

Most tests parse dump files generated with the cppcheck binary

(see conftest.py); tests of pure helper classes construct the

objects directly from dicts (which provide the same .get() API

as the XML elements).

"""

import json

import sys

import pytest

import cppcheckdata

def find_tokens(cfg, token_str):

return [tok for tok in cfg.tokenlist if tok.str == token_str]

def find_token(cfg, token_str, skip=0):

tokens = find_tokens(cfg, token_str)

assert len(tokens) > skip, "token '%s' (skip=%d) not found" % (token_str, skip)

return tokens[skip]

def find_function(cfg, name):

for function in cfg.functions:

if function.name == name:

return function

assert False, "function '%s' not found" % name

def find_scope(cfg, scope_type, className=None):

for scope in cfg.scopes:

if scope.type == scope_type and (className is None or scope.className == className):

return scope

assert False, "scope '%s' not found" % scope_type

def find_variable(cfg, name):

for variable in cfg.variables:

if variable.nameToken and variable.nameToken.str == name:

return variable

assert False, "variable '%s' not found" % name

class TestCppcheckData:

def test_language(self, sample_data, sample_cpp_data):

assert sample_data.language == 'c'

assert sample_cpp_data.language == 'cpp'

def test_platform(self, sample_data):

platform = sample_data.platform

assert platform.name

assert platform.char_bit == 8

assert platform.short_bit >= 16

assert platform.int_bit >= 16

assert platform.long_bit >= 32

assert platform.long_long_bit >= 64

assert platform.pointer_bit > 0

assert 'char_bit=8' in repr(platform)

def test_files(self, sample_data):

assert len(sample_data.files) == 1

assert sample_data.files[0].endswith('sample.c')

def test_rawtokens(self, sample_data):

raw = sample_data.rawTokens

# the not yet preprocessed code contains the directive tokens

assert [tok.str for tok in raw[:4]] == ['#', 'define', 'ANSWER', '42']

assert raw[-1].str == '}'

assert raw[0].file.endswith('sample.c')

assert raw[0].linenr == 1

# next/previous chain

assert raw[0].previous is None

assert raw[-1].next is None

for i in range(len(raw) - 1):

assert raw[i].next is raw[i + 1]

assert raw[i + 1].previous is raw[i]

def test_configurations(self, sample_data):

cfgs = sample_data.configurations

assert len(cfgs) == 1

assert cfgs[0].name == ''

def test_iterconfigurations(self, multi_cfg_data):

it = multi_cfg_data.iterconfigurations()

cfgs = list(it)

assert len(cfgs) == 2

assert cfgs[0].name == ''

assert 'FOO' in cfgs[1].name

# 'foo()' is only tokenized in the FOO configuration

assert not find_tokens(cfgs[0], 'foo')

assert find_tokens(cfgs[1], 'foo')

def test_standards(self, sample_cfg, sample_cpp_cfg):

assert sample_cfg.standards.c.startswith('c')

assert sample_cpp_cfg.standards.cpp.startswith('c++')

assert sample_cfg.standards.posix is False

assert 'c=' in repr(sample_cfg.standards)

class TestToken:

def test_tokenlist(self, sample_cfg):

code = ' '.join(tok.str for tok in sample_cfg.tokenlist)

assert 'static int add ( int a , int b )' in code

# the macro has been expanded

assert 'x = 42' in code

def test_next_previous(self, sample_cfg):

tokens = sample_cfg.tokenlist

assert tokens[0].previous is None

assert tokens[-1].next is None

for i in range(len(tokens) - 1):

assert tokens[i].next is tokens[i + 1]

assert tokens[i + 1].previous is tokens[i]

def test_location(self, sample_cfg):

tok = sample_cfg.tokenlist[0]

assert tok.str == 'static'

assert tok.file.endswith('sample.c')

assert tok.linenr == 2

assert tok.column == 1

def test_link(self, sample_cfg):

parenthesis = find_token(sample_cfg, '(')

assert parenthesis.link.str == ')'

assert parenthesis.link.link is parenthesis

bracket = find_token(sample_cfg, '[')

assert bracket.link.str == ']'

brace = find_token(sample_cfg, '{')

assert brace.link.str == '}'

def test_scope(self, sample_cfg):

assert sample_cfg.tokenlist[0].scope.type == 'Global'

return_tok = find_token(sample_cfg, 'return')

assert return_tok.scope.type == 'Function'

assert return_tok.scope.className == 'add'

def test_name_number_flags(self, sample_cfg):

name_tok = find_token(sample_cfg, 'main')

assert name_tok.isName

assert not name_tok.isNumber

num_tok = find_token(sample_cfg, '42')

assert num_tok.isNumber

assert num_tok.isInt

assert not num_tok.isFloat

float_tok = find_token(sample_cfg, '2.0')

assert float_tok.isNumber

assert float_tok.isFloat

def test_operator_flags(self, sample_cfg, sample_cpp_cfg):

plus = find_token(sample_cfg, '+')

assert plus.isOp

assert plus.isArithmeticalOp

assign = find_token(sample_cfg, '=')

assert assign.isOp

assert assign.isAssignmentOp

logical = find_token(sample_cpp_cfg, '&&')

assert logical.isOp

assert logical.isLogicalOp

comparison = find_token(sample_cpp_cfg, '>')

assert comparison.isOp

assert comparison.isComparisonOp

def test_string_char(self, sample_cpp_cfg):

string_tok = find_token(sample_cpp_cfg, '"hello"')

assert string_tok.isString

assert string_tok.strlen == 5

char_tok = find_token(sample_cpp_cfg, "'x'")

assert char_tok.isChar

@pytest.mark.xfail(strict=False,

reason='Tokenizer::dump checks Token::isName() before Token::isBoolean() and '

'eBoolean tokens are names, so type="boolean" is never dumped')

def test_boolean(self, sample_cpp_cfg):

bool_tok = find_token(sample_cpp_cfg, 'true')

assert bool_tok.isBoolean

def test_cast(self, sample_cpp_cfg):

# static_cast<int>(...) is simplified to a C-style cast

assert any(tok.isCast for tok in sample_cpp_cfg.tokenlist)

def test_macro_expansion(self, sample_cfg):

tok = find_token(sample_cfg, '42')

assert tok.isExpandedMacro

assert tok.macroName == 'ANSWER'

def test_removed_void_parameter(self, sample_cfg):

main_tok = find_token(sample_cfg, 'main')

assert main_tok.next.isRemovedVoidParameter

def test_splitted_var_decl(self, sample_cfg):

# 'int x = ANSWER;' is simplified to 'int x ; x = 42 ;'

assert any(tok.isSplittedVarDeclEq for tok in sample_cfg.tokenlist)

def test_variable_and_var_id(self, sample_cfg):

x_decl = find_token(sample_cfg, 'x')

assert x_decl.varId

assert x_decl.variable.nameToken is x_decl

# all 'x' tokens refer to the same variable and varId

for tok in find_tokens(sample_cfg, 'x'):

assert tok.varId == x_decl.varId

assert tok.variable is x_decl.variable

def test_function(self, sample_cfg):

add_call = find_token(sample_cfg, 'add', skip=1)

assert add_call.function

assert add_call.function.name == 'add'

def test_value_type(self, sample_cfg):

x_tok = find_token(sample_cfg, 'x')

assert x_tok.valueType.type == 'int'

assert x_tok.valueType.sign == 'signed'

assert x_tok.valueType.pointer == 0

assert x_tok.valueType.isIntegral()

assert not x_tok.valueType.isFloat()

assert not x_tok.valueType.isEnum()

d_tok = find_token(sample_cfg, 'd')

assert d_tok.valueType.type == 'double'

assert d_tok.valueType.isFloat()

# in 'arr[0] = ...' the array decays to a pointer

arr_use = find_token(sample_cfg, 'arr', skip=1)

assert arr_use.valueType.pointer == 1

def test_value_type_enum(self, sample_cpp_cfg):

color_tok = find_token(sample_cpp_cfg, 'color')

assert color_tok.valueType.isEnum()

assert color_tok.valueType.typeScope.className == 'Color'

def test_ast(self, sample_cfg):

plus = find_token(sample_cfg, '+')

assert plus.astOperand1.str == 'a'

assert plus.astOperand2.str == 'b'

assert plus.astParent.str == 'return'

assert plus.isBinaryOp()

assert not plus.isUnaryOp('+')

def test_ast_unary_op(self, sample_cfg):

# the '-' in 'int neg = -x;'

minus = find_token(sample_cfg, '-')

assert minus.isUnaryOp('-')

assert not minus.isBinaryOp()

assert minus.astOperand1.str == 'x'

assert minus.astOperand2 is None

def test_ast_parents_top(self, sample_cfg):

a_tok = find_token(sample_cfg, 'a', skip=1) # the 'a' in 'return a + b;'

assert [tok.str for tok in a_tok.astParents()] == ['+', 'return']

assert a_tok.astTop().str == 'return'

def test_values(self, sample_cfg):

# 'x' has the known value 42 when it is used

x_use = find_token(sample_cfg, 'x', skip=2)

assert x_use.getKnownIntValue() == 42

value = x_use.getValue(42)

assert value.intvalue == 42

assert value.isKnown()

assert not value.isPossible()

assert x_use.getValue(43) is None

assert 'intvalue=42' in repr(value)

def test_values_possible(self, sample_cfg):

# inside add() the argument 'a' has the possible value 42

a_use = find_token(sample_cfg, 'a', skip=1)

assert a_use.getKnownIntValue() is None

value = a_use.getValue(42)

assert value is not None

assert value.isPossible()

def test_impossible_values(self, sample_cfg):

# impossible values are separated from the possible/known ones

arr_tokens = find_tokens(sample_cfg, 'arr')

impossible = [v for tok in arr_tokens for v in tok.impossible_values]

assert impossible

assert all(v.isImpossible() for v in impossible)

possible_or_known = [v for tok in arr_tokens for v in tok.values]

assert all(not v.isImpossible() for v in possible_or_known)

def test_forward_backward(self, sample_cfg):

add_def = find_token(sample_cfg, 'add')

strs = [tok.str for tok in add_def.forward()]

assert strs[:4] == ['add', '(', 'int', 'a']

end = add_def.tokAt(2)

assert [tok.str for tok in add_def.forward(end=end)] == ['add', '(']

strs = [tok.str for tok in add_def.backward()]

assert strs[:3] == ['add', 'int', 'static']

start = sample_cfg.tokenlist[0]

assert [tok.str for tok in add_def.backward(start=start)] == ['add', 'int']

def test_tokAt_linkAt(self, sample_cfg):

add_def = find_token(sample_cfg, 'add')

assert add_def.tokAt(0) is add_def

assert add_def.tokAt(1).str == '('

assert add_def.tokAt(-1).str == 'int'

assert add_def.linkAt(1).str == ')'

def test_repr(self, sample_cfg):

tok = sample_cfg.tokenlist[0]

assert "str='static'" in repr(tok)

class TestScope:

def test_scopes(self, sample_cfg):

types = [scope.type for scope in sample_cfg.scopes]

assert types.count('Global') == 1

assert types.count('Function') == 3

def test_global_scope(self, sample_cfg):

global_scope = find_scope(sample_cfg, 'Global')

assert global_scope.nestedIn is None

assert not global_scope.isExecutable

assert len(global_scope.nestedList) == 3

def test_function_scope(self, sample_cfg):

scope = find_scope(sample_cfg, 'Function', className='add')

assert scope.bodyStart.str == '{'

assert scope.bodyEnd.str == '}'

assert scope.bodyStart.link is scope.bodyEnd

assert scope.nestedIn.type == 'Global'

assert scope.function.name == 'add'

assert scope.isExecutable

def test_varlist(self, sample_cfg):

scope = find_scope(sample_cfg, 'Function', className='main')

names = [var.nameToken.str for var in scope.varlist]

assert names == ['x', 'arr', 'neg']

def test_cpp_scopes(self, sample_cpp_cfg):

types = {scope.type for scope in sample_cpp_cfg.scopes}

assert {'Global', 'Namespace', 'Class', 'Enum', 'Function', 'If'} <= types

assert find_scope(sample_cpp_cfg, 'Namespace', className='ns')

assert find_scope(sample_cpp_cfg, 'Class', className='Shape')

if_scope = find_scope(sample_cpp_cfg, 'If')

assert if_scope.isExecutable

class_scope = find_scope(sample_cpp_cfg, 'Class')

assert not class_scope.isExecutable

class TestFunction:

def test_functions(self, sample_cfg):

names = {function.name for function in sample_cfg.functions}

assert names == {'add', 'half', 'main'}

def test_arguments(self, sample_cfg):

add = find_function(sample_cfg, 'add')

assert sorted(add.argument.keys()) == [1, 2]

assert add.argument[1].nameToken.str == 'a'

assert add.argument[2].nameToken.str == 'b'

main = find_function(sample_cfg, 'main')

assert main.argument == {}

def test_attributes(self, sample_cfg):

add = find_function(sample_cfg, 'add')

assert add.isStatic

assert add.type == 'Function'

assert add.tokenDef.str == 'add'

assert add.token.str == 'add'

assert add.nestedIn.type == 'Global'

main = find_function(sample_cfg, 'main')

assert not main.isStatic

def test_virtual(self, sample_cpp_cfg):

area = find_function(sample_cpp_cfg, 'area')

assert area.hasVirtualSpecifier

twice = find_function(sample_cpp_cfg, 'twice')

assert not twice.hasVirtualSpecifier

assert twice.nestedIn.className == 'ns'

class TestVariable:

def test_local(self, sample_cfg):

x = find_variable(sample_cfg, 'x')

assert x.access == 'Local'

assert x.isLocal

assert not x.isArgument

assert not x.isGlobal

assert not x.isArray

assert x.typeStartToken.str == 'int'

assert x.typeEndToken.str == 'int'

assert x.scope.className == 'main'

def test_argument(self, sample_cfg):

a = find_variable(sample_cfg, 'a')

assert a.access == 'Argument'

assert a.isArgument

assert not a.isLocal

def test_array(self, sample_cfg):

arr = find_variable(sample_cfg, 'arr')

assert arr.isArray

assert not arr.isPointer

def test_global_const(self, sample_cpp_cfg):

limit = find_variable(sample_cpp_cfg, 'limit')

assert limit.access == 'Global'

assert limit.isGlobal

assert limit.isConst

assert not limit.isStatic

def test_pointer(self, sample_cpp_cfg):

msg = find_variable(sample_cpp_cfg, 'msg')

assert msg.isPointer

assert not msg.isArray

def test_class_member(self, sample_cpp_cfg):

member = find_variable(sample_cpp_cfg, 'mScale')

assert member.access == 'Protected'

assert member.isClass is False

class TestPreprocessor:

def test_directives(self, sample_cfg):

directives = sample_cfg.directives

assert len(directives) == 1

assert directives[0].str == '#define ANSWER 42'

assert directives[0].file.endswith('sample.c')

assert directives[0].linenr == 1

assert "#define ANSWER 42" in repr(directives[0])

def test_macro_usage(self, sample_cfg):

macros = sample_cfg.macro_usage

assert len(macros) == 1

macro = macros[0]

assert macro.name == 'ANSWER'

assert macro.usefile.endswith('sample.c')

assert int(macro.useline) == 14

assert macro.isKnownValue

assert "name='ANSWER'" in repr(macro)

def test_if_conditions(self, multi_cfg_data):

cfgs = multi_cfg_data.configurations

for cfg in cfgs:

assert len(cfg.preprocessor_if_conditions) == 1

assert cfg.preprocessor_if_conditions[0].linenr == 3

assert cfgs[0].preprocessor_if_conditions[0].result == 0

assert cfgs[1].preprocessor_if_conditions[0].result == 1

assert 'result=' in repr(cfgs[0].preprocessor_if_conditions[0])

def test_typedef_info(self, multi_cfg_data):

cfg = multi_cfg_data.configurations[0]

typedefs = {info.name: info for info in cfg.typedefInfo}

assert set(typedefs.keys()) == {'myint', 'myfloat'}

assert typedefs['myint'].used

assert not typedefs['myfloat'].used

assert typedefs['myint'].linenr == 1

class TestHelperFunctions:

def test_getArguments(self, sample_cfg):

add_call = find_token(sample_cfg, 'add', skip=1)

args = cppcheckdata.getArguments(add_call)

assert [tok.str for tok in args] == ['x', '1']

def test_getArguments_no_call(self, sample_cfg):

int_tok = find_token(sample_cfg, 'int')

assert cppcheckdata.getArguments(int_tok) is None

def test_get_function_call_name_args(self, sample_cfg):

add_call = find_token(sample_cfg, 'add', skip=1)

name, args = cppcheckdata.get_function_call_name_args(add_call)

assert name == 'add'

assert [tok.str for tok in args] == ['x', '1']

def test_get_function_call_name_args_namespace(self, sample_cpp_cfg):

twice_call = find_token(sample_cpp_cfg, 'twice', skip=1)

name, args = cppcheckdata.get_function_call_name_args(twice_call)

assert name == 'ns::twice'

assert [tok.str for tok in args] == ['21']

def test_get_function_call_name_args_not_a_call(self, sample_cfg):

# the function definition is not a call

add_def = find_token(sample_cfg, 'add')

name, args = cppcheckdata.get_function_call_name_args(add_def)

assert name is None

assert args is None

def test_astIsFloat(self, sample_cfg):

division = find_token(sample_cfg, '/')

assert cppcheckdata.astIsFloat(division)

plus = find_token(sample_cfg, '+') # a + b with int operands

assert not cppcheckdata.astIsFloat(plus)

assert not cppcheckdata.astIsFloat(None)

class TestMatch:

"""Tests for the cppcheckdata.match()/simpleMatch() pattern matching."""

def test_simpleMatch(self, match_cfg):

calc_def = find_token(match_cfg, 'calc')

assert cppcheckdata.simpleMatch(calc_def, 'calc')

assert cppcheckdata.simpleMatch(calc_def, 'calc ( int a , int b )')

assert not cppcheckdata.simpleMatch(calc_def, 'calc ( int b')

assert not cppcheckdata.simpleMatch(None, 'calc')

def test_literal_sequence(self, match_cfg):

calc_def = find_token(match_cfg, 'calc')

assert cppcheckdata.match(calc_def, 'calc ( int')

assert cppcheckdata.match(calc_def, 'calc ( int a , int b )')

assert not cppcheckdata.match(calc_def, 'calc ( char')

# the match is anchored at the given token

assert not cppcheckdata.match(calc_def, 'int calc')

def test_empty_pattern_and_no_token(self, match_cfg):

calc_def = find_token(match_cfg, 'calc')

assert not cppcheckdata.match(calc_def, '')

assert not cppcheckdata.match(None, 'calc')

def test_end(self, match_cfg):

calc_def = find_token(match_cfg, 'calc')

res = cppcheckdata.match(calc_def, 'calc')

assert res.end is calc_def

res = cppcheckdata.match(calc_def, 'calc ( int')

assert res.end.str == 'int'

# ---- literal operator tokens ----

def test_literal_bitwise_or(self, match_cfg):

# a literal '|' in the pattern matches a '|' token ...

bit_or = find_token(match_cfg, '|')

assert cppcheckdata.match(bit_or, '|')

assert cppcheckdata.match(bit_or.previous, '%var% | %var% ;')

# ... but not a '||' token, and it is not an either-or alternation

log_or = find_token(match_cfg, '||')

assert not cppcheckdata.match(log_or, '|')

def test_literal_logical_or(self, match_cfg):

log_or = find_token(match_cfg, '||')

assert cppcheckdata.match(log_or, '||')

assert cppcheckdata.match(log_or.previous, '%var% || %var% ;')

bit_or = find_token(match_cfg, '|')

assert not cppcheckdata.match(bit_or, '||')

def test_literal_not(self, match_cfg):

not_tok = find_token(match_cfg, '!')

assert cppcheckdata.match(not_tok, '! %var% ;')

assert not cppcheckdata.match(find_token(match_cfg, '!='), '!')

def test_literal_not_equal(self, match_cfg):

neq = find_token(match_cfg, '!=')

assert cppcheckdata.match(neq, '!=')

assert cppcheckdata.match(neq.previous, '%var% != %var% ;')

assert not cppcheckdata.match(find_token(match_cfg, '='), '!=')

assert not cppcheckdata.match(neq, '=')

def test_literal_star(self, match_cfg):

mul = find_token(match_cfg, '*')

assert cppcheckdata.match(mul, '*')

assert cppcheckdata.match(mul.previous, '%var% * %var% ;')

def test_literal_percent(self, match_cfg):

mod = find_token(match_cfg, '%')

assert cppcheckdata.match(mod, '%')

assert cppcheckdata.match(mod.previous, '%var% % %var% ;')

def test_literal_parentheses(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

assert cppcheckdata.match(calc_call, 'calc ( %var% , %var% ) ;')

# ---- %keyword% patterns ----

def test_any(self, match_cfg):

for token_str in ('calc', '(', '3', ';', '|', '{'):

assert cppcheckdata.match(find_token(match_cfg, token_str), '%any%')

plus_assign = find_token(match_cfg, '+=')

assert cppcheckdata.match(plus_assign, '%assign% %any% ;')

def test_assign(self, match_cfg):

assert cppcheckdata.match(find_token(match_cfg, '='), '%assign%')

assert cppcheckdata.match(find_token(match_cfg, '+='), '%assign%')

assert not cppcheckdata.match(find_token(match_cfg, '!='), '%assign%')

assert not cppcheckdata.match(find_token(match_cfg, '|'), '%assign%')

def test_comp(self, match_cfg):

assert cppcheckdata.match(find_token(match_cfg, '>'), '%comp%')

assert cppcheckdata.match(find_token(match_cfg, '!='), '%comp%')

assert not cppcheckdata.match(find_token(match_cfg, '='), '%comp%')

assert not cppcheckdata.match(find_token(match_cfg, '|'), '%comp%')

def test_name(self, match_cfg):

assert cppcheckdata.match(find_token(match_cfg, 'calc'), '%name%')

assert cppcheckdata.match(find_token(match_cfg, 'int'), '%name%')

assert not cppcheckdata.match(find_token(match_cfg, '3'), '%name%')

assert not cppcheckdata.match(find_token(match_cfg, '('), '%name%')

def test_op(self, match_cfg):

for op in ('|', '||', '*', '%', '!=', '>', '=', '+='):

assert cppcheckdata.match(find_token(match_cfg, op), '%op%'), op

assert not cppcheckdata.match(find_token(match_cfg, ';'), '%op%')

assert not cppcheckdata.match(find_token(match_cfg, 'calc'), '%op%')

def test_or(self, match_cfg):

assert cppcheckdata.match(find_token(match_cfg, '|'), '%or%')

assert not cppcheckdata.match(find_token(match_cfg, '||'), '%or%')

def test_oror(self, match_cfg):

assert cppcheckdata.match(find_token(match_cfg, '||'), '%oror%')

assert not cppcheckdata.match(find_token(match_cfg, '|'), '%oror%')

def test_var(self, match_cfg):

a_use = find_token(match_cfg, 'a', skip=1)

assert cppcheckdata.match(a_use, '%var%')

# a function name is a %name% but not a %var%

assert not cppcheckdata.match(find_token(match_cfg, 'calc'), '%var%')

assert not cppcheckdata.match(find_token(match_cfg, '3'), '%var%')

# ---- link patterns ----

def test_link_parentheses(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

res = cppcheckdata.match(calc_call.next, '(*)')

assert res

assert res.end.str == ')'

assert res.end is calc_call.next.link

# the pattern continues after the linked token

assert cppcheckdata.match(calc_call, '%name% (*) ;')

# '(*)' only matches at a '(' token

assert not cppcheckdata.match(calc_call, '(*)')

def test_link_brackets(self, match_cfg):

arr_decl = find_token(match_cfg, 'arr')

assert cppcheckdata.match(arr_decl, 'arr [*] ;')

arr_use = find_token(match_cfg, 'arr', skip=1)

res = cppcheckdata.match(arr_use, '%name% [*] %assign% %var% ;')

assert res

def test_link_braces(self, match_cfg):

if_scope = find_scope(match_cfg, 'If')

res = cppcheckdata.match(if_scope.bodyStart, '{*}')

assert res

assert res.end is if_scope.bodyEnd

def test_link_combined(self, match_cfg):

if_tok = find_token(match_cfg, 'if')

res = cppcheckdata.match(if_tok, 'if (*) {*}')

assert res

assert res.end.str == '}'

def test_link_angle_brackets(self, match_cpp_cfg):

# the '<' of 'std::vector<int>' is linked to the '>'

template_lt = find_token(match_cpp_cfg, '<')

assert template_lt.link

res = cppcheckdata.match(template_lt, '<*>')

assert res

assert res.end.str == '>'

assert cppcheckdata.match(template_lt.previous, 'vector <*> %var%')

# the '<' in 'i < j' is a comparison without a link

comparison_lt = find_token(match_cpp_cfg, '<', skip=1)

assert comparison_lt.link is None

assert not cppcheckdata.match(comparison_lt, '<*>')

# ---- either-or alternation ----

def test_alternatives(self, match_cfg):

struct_tok = find_token(match_cfg, 'struct')

assert cppcheckdata.match(struct_tok, 'struct|class %name% {')

assert not cppcheckdata.match(struct_tok, 'union|enum %name% {')

def test_alternatives_cpp(self, match_cpp_cfg):

class_tok = find_token(match_cpp_cfg, 'class')

assert cppcheckdata.match(class_tok, 'struct|class %name% {')

def test_alternatives_with_keyword(self, match_cfg):

struct_tok = find_token(match_cfg, 'struct')

assert cppcheckdata.match(struct_tok, '%op%|struct')

assert not cppcheckdata.match(struct_tok, '%op%|%comp%')

# ---- negation ----

def test_negation(self, match_cfg):

struct_tok = find_token(match_cfg, 'struct')

assert cppcheckdata.match(struct_tok, 'struct !!;')

assert not cppcheckdata.match(struct_tok, 'struct !!Point')

def test_negation_keyword(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

assert cppcheckdata.match(calc_call, '%name% !!%op%')

assert not cppcheckdata.match(calc_call, '%name% !!(')

@pytest.mark.xfail(strict=False,

reason='in the C++ Token::Match a negation also matches when there is no token, '

'in match() it does not')

def test_negation_no_token(self, match_cfg):

last = match_cfg.tokenlist[-1]

assert last.str == '}'

assert cppcheckdata.match(last, '} !!x')

# ---- bindings ----

def test_bindings(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

res = cppcheckdata.match(calc_call, '%name%@ftok (*)')

assert res

assert res.ftok is calc_call

assert res.ftok.str == 'calc'

assert res.end.str == ')'

def test_multiple_bindings(self, match_cfg):

bit_or_lhs = find_token(match_cfg, 'bit_or', skip=1)

res = cppcheckdata.match(bit_or_lhs, '%var%@lhs = %var%@op1 | %var%@op2 ;')

assert res

assert res.lhs.str == 'bit_or'

assert res.op1.str == 'a'

assert res.op2.str == 'b'

def test_binding_on_link_pattern(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

# the binding is the '(' token, end is behind the linked ')'

res = cppcheckdata.match(calc_call, '%name% (*)@paren')

assert res

assert res.paren.str == '('

assert res.paren.link is res.end

def test_bindings_on_failure(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

res = cppcheckdata.match(calc_call, '%name%@ftok [*]@brackets')

assert not res

# all bindings (including 'end') read as None on a failed match

assert res.ftok is None

assert res.brackets is None

assert res.end is None

def test_unknown_binding_raises(self, match_cfg):

calc_call = find_token(match_cfg, 'calc', skip=1)

res = cppcheckdata.match(calc_call, '%name%@ftok (*)')

assert res

with pytest.raises(AttributeError):

res.nosuchbinding # pylint: disable=W0104

res = cppcheckdata.match(calc_call, '%name%@ftok [*]')

assert not res

with pytest.raises(AttributeError):

res.nosuchbinding # pylint: disable=W0104

# ---- '**' forward search ----

def test_find_forward(self, match_cfg):

calc_def = find_token(match_cfg, 'calc')

# '**' searches forward, skipping linked groups: the '{' found here

# is the function body, not a '{' inside the parameter list

res = cppcheckdata.match(calc_def, 'calc **{')

assert res

assert res.end.str == '{'

assert not cppcheckdata.match(calc_def, 'calc **nosuchtoken')

class TestSuppressions:

def make_suppression(self, **kwargs):

return cppcheckdata.Suppression(kwargs)

def test_line_suppression(self):

supp = self.make_suppression(errorId='zerodiv', lineNumber='5')

assert supp.isMatch('a.c', '5', 'msg', 'zerodiv')

assert not supp.isMatch('a.c', '5', 'msg', 'nullPointer')

@pytest.mark.xfail(strict=False,

reason='the "other suppression" fallback in Suppression.isMatch() does not check '

'that lineNumber is unset, so a line suppression matches every line')

def test_line_suppression_other_line(self):

supp = self.make_suppression(errorId='zerodiv', lineNumber='5')

assert not supp.isMatch('a.c', '6', 'msg', 'zerodiv')

def test_wildcard_errorId(self):

supp = self.make_suppression(errorId='*', lineNumber='5')

assert supp.isMatch('a.c', '5', 'msg', 'anything')

def test_file_suppression(self):

supp = self.make_suppression(errorId='zerodiv', fileName='a.c', type='file')

assert supp.isMatch('a.c', '1', 'msg', 'zerodiv')

assert supp.isMatch('a.c', '99', 'msg', 'zerodiv')

assert not supp.isMatch('b.c', '1', 'msg', 'zerodiv')

def test_block_suppression(self):

supp = self.make_suppression(errorId='zerodiv', type='block', lineBegin='3', lineEnd='7')

assert supp.isMatch('a.c', '5', 'msg', 'zerodiv')

assert not supp.isMatch('a.c', '3', 'msg', 'zerodiv')

assert not supp.isMatch('a.c', '7', 'msg', 'zerodiv')

def test_global_suppression(self):

supp = self.make_suppression(errorId='zerodiv')

assert supp.isMatch('a.c', '1', 'msg', 'zerodiv')

assert supp.isMatch('b.c', '99', 'other', 'zerodiv')

def test_symbolName(self):

supp = self.make_suppression(errorId='zerodiv', symbolName='xyz')

assert supp.isMatch('a.c', '1', 'error on xyz here', 'zerodiv')

assert not supp.isMatch('a.c', '1', 'other message', 'zerodiv')

def test_dumpfile_suppressions(self, dump_factory):

code = ('void f(void)\n'

'{\n'

' int a;\n'

' // cppcheck-suppress uninitvar\n'

' a++;\n'

'}\n')

data = dump_factory.parse(code, extra_args=['--inline-suppr'])

assert len(data.suppressions) == 1

supp = data.suppressions[0]

assert supp.errorId == 'uninitvar'

assert supp.fileName.endswith('test.c')

assert int(supp.lineNumber) == 5

# parsedump() also sets the suppressions used by is_suppressed()

location = cppcheckdata.Location({'file': supp.fileName, 'line': '5', 'column': '5'})

assert cppcheckdata.is_suppressed(location, 'msg', 'uninitvar')

assert not cppcheckdata.is_suppressed(location, 'msg', 'nullPointer')

# NOTE: a non-matching line is not checked here - see test_line_suppression_other_line

class TestPureHelpers:

"""Tests that construct objects from dicts and do not need a dump file."""

def test_location(self):

loc = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})

assert loc.file == 'a.c'

assert loc.linenr == 3

assert loc.column == 7

def test_location_defaults(self):

loc = cppcheckdata.Location({'file': 'a.c'})

assert loc.linenr == 0

assert loc.column == 0

def test_location_linenr_alias(self):

loc = cppcheckdata.Location({'file': 'a.c', 'linenr': '4'})

assert loc.linenr == 4

def test_value_kinds(self):

known = cppcheckdata.Value({'intvalue': '42', 'known': 'true'})

assert known.intvalue == 42

assert known.isKnown()

assert not known.isPossible()

possible = cppcheckdata.Value({'intvalue': '1', 'possible': 'true'})

assert possible.isPossible()

impossible = cppcheckdata.Value({'intvalue': '0', 'impossible': 'true'})

assert impossible.isImpossible()

inconclusive = cppcheckdata.Value({'intvalue': '2', 'inconclusive': 'true'})

assert inconclusive.isInconclusive()

def test_value_condition(self):

value = cppcheckdata.Value({'intvalue': '1', 'possible': 'true', 'condition-line': '12'})

assert value.condition == 12

def test_argument_parser(self):

parser = cppcheckdata.ArgumentParser()

args = parser.parse_args(['a.dump', 'b.ctu-info', '--cli', '-q'])

assert args.dumpfile == ['a.dump', 'b.ctu-info']

assert args.cli

assert args.quiet

assert args.file_list is None

assert '{severity}' in args.template

def test_get_files(self, tmp_path):

file_list = tmp_path / 'files.txt'

file_list.write_text('c.dump\nd.ctu-info\n')

parser = cppcheckdata.ArgumentParser()

args = parser.parse_args(['a.dump', 'b.ctu-info', '--file-list', str(file_list)])

dump_files, ctu_info_files = cppcheckdata.get_files(args)

assert dump_files == ['a.dump', 'c.dump']

assert ctu_info_files == ['b.ctu-info', 'd.ctu-info']

class TestReporting:

def test_reportError_cli(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])

location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})

cppcheckdata.reportError(location, 'error', 'the message', 'myaddon', 'myid', extra='extra info')

msg = json.loads(capsys.readouterr().out)

assert msg == {'file': 'a.c',

'linenr': 3,

'column': 7,

'severity': 'error',

'message': 'the message',

'addon': 'myaddon',

'errorId': 'myid',

'extra': 'extra info'}

def test_reportError_cli_column_override(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])

location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})

cppcheckdata.reportError(location, 'error', 'the message', 'myaddon', 'myid', columnOverride=42)

msg = json.loads(capsys.readouterr().out)

assert msg['column'] == 42

def test_reportError_stderr(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py'])

monkeypatch.setattr(cppcheckdata, 'current_dumpfile_suppressions', [])

monkeypatch.setattr(cppcheckdata, 'EXIT_CODE', 0)

location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})

cppcheckdata.reportError(location, 'style', 'the message', 'myaddon', 'myid')

stderr = capsys.readouterr().err

assert stderr == '[a.c:3] (style) the message [myaddon-myid]\n'

assert cppcheckdata.EXIT_CODE == 1

def test_reportError_stderr_suppressed(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py'])

suppression = cppcheckdata.Suppression({'errorId': 'myaddon-myid'})

monkeypatch.setattr(cppcheckdata, 'current_dumpfile_suppressions', [suppression])

monkeypatch.setattr(cppcheckdata, 'EXIT_CODE', 0)

location = cppcheckdata.Location({'file': 'a.c', 'line': '3', 'column': '7'})

cppcheckdata.reportError(location, 'style', 'the message', 'myaddon', 'myid')

assert capsys.readouterr().err == ''

assert cppcheckdata.EXIT_CODE == 0

def test_log_checker_cli(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py', '--cli'])

cppcheckdata.log_checker('SomeChecker', 'myaddon')

msg = json.loads(capsys.readouterr().out)

assert msg == {'addon': 'myaddon',

'severity': 'none',

'message': 'SomeChecker',

'errorId': 'logChecker'}

def test_log_checker_no_cli(self, monkeypatch, capsys):

monkeypatch.setattr(sys, 'argv', ['myaddon.py'])

cppcheckdata.log_checker('SomeChecker', 'myaddon')

assert capsys.readouterr().out == ''