/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "testsuite.h"

#include "tokenize.h"

#include "token.h"

#include "settings.h"

#include "path.h"

#include <cstring>

#include <stack>

extern std::ostringstream errout;

class TestTokenizer : public TestFixture {

public:

TestTokenizer() : TestFixture("TestTokenizer") {

}

private:

void run() {

TEST_CASE(tokenize1);

TEST_CASE(tokenize2);

TEST_CASE(tokenize3);

TEST_CASE(tokenize4);

TEST_CASE(tokenize5);

TEST_CASE(tokenize6); // array access. replace "*(p+1)" => "p[1]"

TEST_CASE(tokenize7);

TEST_CASE(tokenize8);

TEST_CASE(tokenize9);

TEST_CASE(tokenize10);

TEST_CASE(tokenize11);

TEST_CASE(tokenize12);

TEST_CASE(tokenize13); // bailout if the code contains "@" - that is not handled well.

TEST_CASE(tokenize14); // tokenize "0X10" => 16

TEST_CASE(tokenize15); // tokenize ".123"

TEST_CASE(tokenize16); // #2612 - segfault for "<><<"

TEST_CASE(tokenize17); // #2759

TEST_CASE(tokenize18); // tokenize "(X&&Y)" into "( X && Y )" instead of "( X & & Y )"

TEST_CASE(tokenize19); // #3006 (segmentation fault)

TEST_CASE(tokenize20); // replace C99 _Bool => bool

TEST_CASE(tokenize21); // tokenize 0x0E-7

TEST_CASE(tokenize22); // special marker $ from preprocessor

TEST_CASE(tokenize24); // #4195 (segmentation fault)

TEST_CASE(tokenize25); // #4239 (segmentation fault)

TEST_CASE(tokenize26); // #4245 (segmentation fault)

TEST_CASE(tokenize27); // #4525 (segmentation fault)

TEST_CASE(tokenize28); // #4725 (writing asm() around "^{}")

TEST_CASE(tokenize29); // #5506 (segmentation fault upon invalid code)

// don't freak out when the syntax is wrong

TEST_CASE(wrong_syntax1);

TEST_CASE(wrong_syntax2);

TEST_CASE(wrong_syntax3); // #3544

TEST_CASE(wrong_syntax4); // #3618

TEST_CASE(wrong_syntax_if_macro); // #2518 - if MACRO()

TEST_CASE(wrong_syntax_class_x_y); // #3585 - class x y { };

TEST_CASE(syntax_case_default);

TEST_CASE(garbageCode1);

TEST_CASE(garbageCode2); // #4300

TEST_CASE(garbageCode3); // #4869

TEST_CASE(garbageCode4); // #4887

TEST_CASE(garbageCode5); // #5168

TEST_CASE(garbageCode6); // #5214

TEST_CASE(garbageCode7);

TEST_CASE(simplifyFileAndLineMacro); // tokenize "return - __LINE__;"

TEST_CASE(foreach); // #3690

TEST_CASE(concatenateNegativeNumber);

TEST_CASE(longtok);

TEST_CASE(removeCast1);

TEST_CASE(removeCast2);

TEST_CASE(removeCast3);

TEST_CASE(removeCast4);

TEST_CASE(removeCast5);

TEST_CASE(removeCast6);

TEST_CASE(removeCast7);

TEST_CASE(removeCast8);

TEST_CASE(removeCast9);

TEST_CASE(removeCast10);

TEST_CASE(removeCast11);

TEST_CASE(removeCast12);

TEST_CASE(removeCast13);

TEST_CASE(removeCast14);

TEST_CASE(simplifyFloatCasts); // float casting a integer

TEST_CASE(inlineasm);

TEST_CASE(ifAddBraces1);

TEST_CASE(ifAddBraces2);

TEST_CASE(ifAddBraces3);

TEST_CASE(ifAddBraces4);

TEST_CASE(ifAddBraces5);

TEST_CASE(ifAddBraces6);

TEST_CASE(ifAddBraces7);

TEST_CASE(ifAddBraces9);

TEST_CASE(ifAddBraces10);

TEST_CASE(ifAddBraces11);

TEST_CASE(ifAddBraces12);

TEST_CASE(ifAddBraces13);

TEST_CASE(ifAddBraces14); // #2610 - segfault: if()<{}

TEST_CASE(ifAddBraces15); // #2616 - unknown macro before if

TEST_CASE(ifAddBraces16); // ticket # 2739 (segmentation fault)

TEST_CASE(ifAddBraces17); // '} else' should be in the same line

TEST_CASE(ifAddBraces18); // #3424 - if if { } else else

TEST_CASE(ifAddBraces19); // #3928 - if for if else

TEST_CASE(ifAddBraces20); // #5012 - syntax error 'else }'

TEST_CASE(whileAddBraces);

TEST_CASE(doWhileAddBraces);

TEST_CASE(forAddBraces1);

TEST_CASE(forAddBraces2); // #5088

TEST_CASE(pointers_condition);

TEST_CASE(simplifyKnownVariables1);

TEST_CASE(simplifyKnownVariables2);

TEST_CASE(simplifyKnownVariables3);

TEST_CASE(simplifyKnownVariables4);

TEST_CASE(simplifyKnownVariables5);

TEST_CASE(simplifyKnownVariables6);

TEST_CASE(simplifyKnownVariables7);

TEST_CASE(simplifyKnownVariables8);

TEST_CASE(simplifyKnownVariables9);

TEST_CASE(simplifyKnownVariables10);

TEST_CASE(simplifyKnownVariables11);

TEST_CASE(simplifyKnownVariables12);

TEST_CASE(simplifyKnownVariables13);

TEST_CASE(simplifyKnownVariables14);

TEST_CASE(simplifyKnownVariables15);

TEST_CASE(simplifyKnownVariables16);

TEST_CASE(simplifyKnownVariables17);

TEST_CASE(simplifyKnownVariables18);

TEST_CASE(simplifyKnownVariables19);

TEST_CASE(simplifyKnownVariables20);

TEST_CASE(simplifyKnownVariables21);

TEST_CASE(simplifyKnownVariables22);

TEST_CASE(simplifyKnownVariables23);

TEST_CASE(simplifyKnownVariables24);

TEST_CASE(simplifyKnownVariables25);

TEST_CASE(simplifyKnownVariables26);

TEST_CASE(simplifyKnownVariables27);

TEST_CASE(simplifyKnownVariables28);

TEST_CASE(simplifyKnownVariables29); // ticket #1811

TEST_CASE(simplifyKnownVariables30);

TEST_CASE(simplifyKnownVariables31);

TEST_CASE(simplifyKnownVariables32); // const

TEST_CASE(simplifyKnownVariables33); // struct variable

TEST_CASE(simplifyKnownVariables34);

TEST_CASE(simplifyKnownVariables35); // ticket #2353 - False positive: Division by zero 'if (x == 0) return 0; return 10 / x;'

TEST_CASE(simplifyKnownVariables36); // ticket #2304 - known value for strcpy parameter

TEST_CASE(simplifyKnownVariables37); // ticket #2398 - false positive caused by no simplification in for loop

TEST_CASE(simplifyKnownVariables38); // ticket #2399 - simplify conditions

TEST_CASE(simplifyKnownVariables39);

TEST_CASE(simplifyKnownVariables40);

TEST_CASE(simplifyKnownVariables41); // p=&x; if (p) ..

TEST_CASE(simplifyKnownVariables42); // ticket #2031 - known string value after strcpy

TEST_CASE(simplifyKnownVariables43);

TEST_CASE(simplifyKnownVariables44); // ticket #3117 - don't simplify static variables

TEST_CASE(simplifyKnownVariables45); // ticket #3281 - static constant variable not simplified

TEST_CASE(simplifyKnownVariables46); // ticket #3587 - >>

TEST_CASE(simplifyKnownVariables47); // ticket #3627 - >>

TEST_CASE(simplifyKnownVariables48); // ticket #3754 - wrong simplification in for loop header

TEST_CASE(simplifyKnownVariables49); // #3691 - continue in switch

TEST_CASE(simplifyKnownVariables50); // #4066 sprintf changes

TEST_CASE(simplifyKnownVariables51); // #4409 hang

TEST_CASE(simplifyKnownVariables52); // #4728 "= x %cop%"

TEST_CASE(simplifyKnownVariables53); // references

TEST_CASE(simplifyKnownVariables54); // #4913 'x' is not 0 after *--x=0;

TEST_CASE(simplifyKnownVariables55); // pointer alias

TEST_CASE(simplifyKnownVariables56); // ticket #5301 - >>

TEST_CASE(simplifyKnownVariablesIfEq1); // if (a==5) => a is 5 in the block

TEST_CASE(simplifyKnownVariablesIfEq2); // if (a==5) { buf[a++] = 0; }

TEST_CASE(simplifyKnownVariablesIfEq3); // #4708 - if (a==5) { buf[--a] = 0; }

TEST_CASE(simplifyKnownVariablesBailOutAssign1);

TEST_CASE(simplifyKnownVariablesBailOutAssign2);

TEST_CASE(simplifyKnownVariablesBailOutAssign3); // #4395 - nested assignments

TEST_CASE(simplifyKnownVariablesBailOutFor1);

TEST_CASE(simplifyKnownVariablesBailOutFor2);

TEST_CASE(simplifyKnownVariablesBailOutFor3);

TEST_CASE(simplifyKnownVariablesBailOutMemberFunction);

TEST_CASE(simplifyKnownVariablesBailOutConditionalIncrement);

TEST_CASE(simplifyKnownVariablesBailOutSwitchBreak); // ticket #2324

TEST_CASE(simplifyKnownVariablesFloat); // #2454 - float variable

TEST_CASE(simplifyKnownVariablesClassMember); // #2815 - value of class member may be changed by function call

TEST_CASE(simplifyKnownVariablesFunctionCalls); // Function calls (don't assume pass by reference)

TEST_CASE(simplifyKnownVariablesReturn); // 3500 - return

TEST_CASE(simplifyExternC);

TEST_CASE(varid1);

TEST_CASE(varid2);

TEST_CASE(varid3);

TEST_CASE(varid4);

TEST_CASE(varid5);

TEST_CASE(varid6);

TEST_CASE(varid7);

TEST_CASE(varidReturn1);

TEST_CASE(varidReturn2);

TEST_CASE(varid8);

TEST_CASE(varid9);

TEST_CASE(varid10);

TEST_CASE(varid11);

TEST_CASE(varid12);

TEST_CASE(varid13);

TEST_CASE(varid14);

TEST_CASE(varid15);

TEST_CASE(varid16);

TEST_CASE(varid17); // ticket #1810

TEST_CASE(varid18);

TEST_CASE(varid19);

TEST_CASE(varid20);

TEST_CASE(varid24);

TEST_CASE(varid25);

TEST_CASE(varid26); // ticket #1967 (list of function pointers)

TEST_CASE(varid27); // Ticket #2280 (same name for namespace and variable)

TEST_CASE(varid28); // ticket #2630

TEST_CASE(varid29); // ticket #1974

TEST_CASE(varid30); // ticket #2614

TEST_CASE(varid31); // ticket #2831 (segmentation fault)

TEST_CASE(varid32); // ticket #2835 (segmentation fault)

TEST_CASE(varid33); // ticket #2875 (segmentation fault)

TEST_CASE(varid34); // ticket #2825

TEST_CASE(varid35); // ticket #2937

TEST_CASE(varid36); // ticket #2980 (segmentation fault)

TEST_CASE(varid37); // ticket #3092 (varid for 'Bar bar(*this);')

TEST_CASE(varid38); // ticket #3272 (varid for 'FOO class C;')

TEST_CASE(varid39); // ticket #3279 (varid for 'FOO::BAR const')

TEST_CASE(varid40); // ticket #3279

TEST_CASE(varid41); // ticket #3340 (varid for union type)

TEST_CASE(varid42); // ticket #3316 (varid for array)

TEST_CASE(varid43);

TEST_CASE(varid44);

TEST_CASE(varid45); // #3466

TEST_CASE(varid46); // struct varname

TEST_CASE(varid47); // function parameters

TEST_CASE(varid48); // #3785 - return (a*b)

TEST_CASE(varid49); // #3799 - void f(std::vector<int>)

TEST_CASE(varid50); // #3760 - explicit

TEST_CASE(varid51); // don't set varid for template function

TEST_CASE(varid52); // Set varid for nested templates

TEST_CASE(varid53); // #4172 - Template instantiation: T<&functionName> list[4];

TEST_CASE(varid54); // hang

TEST_CASE(varid_cpp_keywords_in_c_code);

TEST_CASE(varidFunctionCall1);

TEST_CASE(varidFunctionCall2);

TEST_CASE(varidFunctionCall3);

TEST_CASE(varidFunctionCall4); // ticket #3280

TEST_CASE(varidStl);

TEST_CASE(varid_delete);

TEST_CASE(varid_functions);

TEST_CASE(varid_sizeof);

TEST_CASE(varid_reference_to_containers);

TEST_CASE(varid_in_class1);

TEST_CASE(varid_in_class2);

TEST_CASE(varid_in_class3); // #3092 - shadow variable in member function

TEST_CASE(varid_in_class4); // #3271 - public: class C;

TEST_CASE(varid_in_class5); // #3584 - std::vector<::FOO::B> b;

TEST_CASE(varid_in_class6); // #3755

TEST_CASE(varid_in_class7); // set variable id for struct members

TEST_CASE(varid_in_class8); // unknown macro in class

TEST_CASE(varid_in_class9); // #4291 - id for variables accessed through 'this'

TEST_CASE(varid_in_class10);

TEST_CASE(varid_in_class11); // #4277 - anonymous union

TEST_CASE(varid_in_class12); // #4637 - method

TEST_CASE(varid_in_class13); // #4637 - method

TEST_CASE(varid_in_class14);

TEST_CASE(varid_initList);

TEST_CASE(varid_operator);

TEST_CASE(varid_throw);

TEST_CASE(varid_unknown_macro); // #2638 - unknown macro is not type

TEST_CASE(varid_using); // ticket #3648

TEST_CASE(varid_catch);

TEST_CASE(varid_functionPrototypeTemplate);

TEST_CASE(varid_templatePtr); // #4319

TEST_CASE(varid_templateNamespaceFuncPtr); // #4172

TEST_CASE(varid_templateArray);

TEST_CASE(varid_variadicFunc);

TEST_CASE(varid_typename); // #4644

TEST_CASE(varid_rvalueref);

TEST_CASE(varidclass1);

TEST_CASE(varidclass2);

TEST_CASE(varidclass3);

TEST_CASE(varidclass4);

TEST_CASE(varidclass5);

TEST_CASE(varidclass6);

TEST_CASE(varidclass7);

TEST_CASE(varidclass8);

TEST_CASE(varidclass9);

TEST_CASE(varidclass10); // variable declaration below usage

TEST_CASE(varidclass11); // variable declaration below usage

TEST_CASE(varidclass12);

TEST_CASE(varidclass13);

TEST_CASE(varidclass14);

TEST_CASE(varidclass15); // initializer list

TEST_CASE(varid_classnameshaddowsvariablename) // #3990

TEST_CASE(file1);

TEST_CASE(file2);

TEST_CASE(file3);

TEST_CASE(line1); // Ticket #4408

TEST_CASE(line2); // Ticket #5423

TEST_CASE(doublesharp);

TEST_CASE(isZeroNumber);

TEST_CASE(isOneNumber);

TEST_CASE(isTwoNumber);

TEST_CASE(macrodoublesharp);

TEST_CASE(simplifyFunctionParameters);

TEST_CASE(simplifyFunctionParameters1); // #3721

TEST_CASE(simplifyFunctionParameters2); // #4430

TEST_CASE(simplifyFunctionParameters3); // #4436

TEST_CASE(simplifyFunctionParametersErrors);

TEST_CASE(removeParentheses1); // Ticket #61

TEST_CASE(removeParentheses2);

TEST_CASE(removeParentheses3);

TEST_CASE(removeParentheses4); // Ticket #390

TEST_CASE(removeParentheses5); // Ticket #392

TEST_CASE(removeParentheses6);

TEST_CASE(removeParentheses7);

TEST_CASE(removeParentheses8); // Ticket #1865

TEST_CASE(removeParentheses9); // Ticket #1962

TEST_CASE(removeParentheses10); // Ticket #2320

TEST_CASE(removeParentheses11); // Ticket #2505

TEST_CASE(removeParentheses12); // Ticket #2760 ',(b)='

TEST_CASE(removeParentheses13);

TEST_CASE(removeParentheses14); // Ticket #3309

TEST_CASE(removeParentheses15); // Ticket #4142

TEST_CASE(removeParentheses16); // Ticket #4423 '*(x.y)='

TEST_CASE(removeParentheses17); // Don't remove parentheses in 'a ? b : (c>0 ? d : e);'

TEST_CASE(tokenize_double);

TEST_CASE(tokenize_strings);

TEST_CASE(simplify_constants);

TEST_CASE(simplify_constants2);

TEST_CASE(simplify_constants3);

TEST_CASE(simplify_constants4);

TEST_CASE(simplify_constants5);

TEST_CASE(simplify_null);

TEST_CASE(simplifyMulAndParens); // Ticket #2784 + #3184

TEST_CASE(simplifyStructDecl);

TEST_CASE(vardecl1);

TEST_CASE(vardecl2);

TEST_CASE(vardecl3);

TEST_CASE(vardecl4);

TEST_CASE(vardec_static);

TEST_CASE(vardecl6);

TEST_CASE(vardecl7);

TEST_CASE(vardecl8);

TEST_CASE(vardecl9);

TEST_CASE(vardecl10);

TEST_CASE(vardecl11);

TEST_CASE(vardecl12);

TEST_CASE(vardecl13);

TEST_CASE(vardecl14);

TEST_CASE(vardecl15);

TEST_CASE(vardecl16);

TEST_CASE(vardecl17);

TEST_CASE(vardecl18);

TEST_CASE(vardecl19);

TEST_CASE(vardecl20); // #3700 - register const int H = 0;

TEST_CASE(vardecl21); // #4042 - a::b const *p = 0;

TEST_CASE(vardecl22); // #4211 - segmentation fault

TEST_CASE(vardecl23); // #4276 - segmentation fault

TEST_CASE(vardecl24); // #4187 - variable declaration within lambda function

TEST_CASE(vardecl25); // #4799 - segmentation fault

TEST_CASE(vardecl_stl_1);

TEST_CASE(vardecl_stl_2);

TEST_CASE(vardecl_template_1);

TEST_CASE(vardecl_template_2);

TEST_CASE(vardecl_union);

TEST_CASE(vardecl_par); // #2743 - set links if variable type contains parentheses

TEST_CASE(vardecl_par2) // #3912 - set correct links

TEST_CASE(volatile_variables);

TEST_CASE(syntax_error);

TEST_CASE(syntax_error_templates_1);

TEST_CASE(syntax_error_templates_2);

TEST_CASE(removeKeywords);

// unsigned i; => unsigned int i;

TEST_CASE(unsigned1);

TEST_CASE(unsigned2);

TEST_CASE(unsigned3); // template arguments

TEST_CASE(simplifyStdType); // #4947, #4950, #4951

TEST_CASE(createLinks);

TEST_CASE(signed1);

TEST_CASE(removeExceptionSpecification1);

TEST_CASE(removeExceptionSpecification2);

TEST_CASE(removeExceptionSpecification3);

TEST_CASE(removeExceptionSpecification4);

TEST_CASE(removeExceptionSpecification5);

TEST_CASE(removeExceptionSpecification6); // #4617

TEST_CASE(simplifyString);

TEST_CASE(simplifyConst);

TEST_CASE(switchCase);

TEST_CASE(simplifyPointerToStandardType);

TEST_CASE(functionpointer1);

TEST_CASE(functionpointer2);

TEST_CASE(functionpointer3);

TEST_CASE(functionpointer4);

TEST_CASE(functionpointer5);

TEST_CASE(removeRedundantAssignment);

TEST_CASE(removedeclspec);

TEST_CASE(removeattribute);

TEST_CASE(cpp0xtemplate1);

TEST_CASE(cpp0xtemplate2);

TEST_CASE(cpp0xtemplate3);

TEST_CASE(arraySize);

TEST_CASE(labels);

TEST_CASE(simplifyInitVar);

TEST_CASE(simplifyInitVar2);

TEST_CASE(simplifyInitVar3);

TEST_CASE(bitfields1);

TEST_CASE(bitfields2);

TEST_CASE(bitfields3);

TEST_CASE(bitfields4); // ticket #1956

TEST_CASE(bitfields5); // ticket #1956

TEST_CASE(bitfields6); // ticket #2595

TEST_CASE(bitfields7); // ticket #1987

TEST_CASE(bitfields8);

TEST_CASE(bitfields9); // ticket #2706

TEST_CASE(bitfields10);

TEST_CASE(bitfields11); // ticket #2845 (segmentation fault)

TEST_CASE(bitfields12); // ticket #3485 (segmentation fault)

TEST_CASE(bitfields13); // ticket #3502 (segmentation fault)

TEST_CASE(bitfields14); // ticket #4561 (segfault for 'class a { signals: };')

TEST_CASE(simplifyNamespaceStd);

TEST_CASE(microsoftMFC);

TEST_CASE(microsoftMemory);

TEST_CASE(borland);

TEST_CASE(Qt);

TEST_CASE(simplifySQL);

TEST_CASE(simplifyLogicalOperators);

TEST_CASE(simplifyCalculations);

// foo(p = new char[10]); => p = new char[10]; foo(p);

TEST_CASE(simplifyAssignmentInFunctionCall);

// "x += .." => "x = x + .."

TEST_CASE(simplifyCompoundAssignment);

// x = ({ 123; }); => { x = 123; }

TEST_CASE(simplifyRoundCurlyParentheses);

TEST_CASE(simplifyOperatorName1);

TEST_CASE(simplifyOperatorName2);

TEST_CASE(simplifyOperatorName3);

TEST_CASE(simplifyOperatorName4);

TEST_CASE(simplifyOperatorName5);

TEST_CASE(simplifyOperatorName6); // ticket #3194

TEST_CASE(simplifyOperatorName7); // ticket #4619

TEST_CASE(simplifyNull);

TEST_CASE(simplifyNullArray);

// Some simple cleanups of unhandled macros in the global scope

TEST_CASE(removeMacrosInGlobalScope);

TEST_CASE(removeMacroInVarDecl);

// a = b = 0;

TEST_CASE(multipleAssignment);

TEST_CASE(platformWin);

TEST_CASE(platformWin32);

TEST_CASE(platformWin32A);

TEST_CASE(platformWin32W);

TEST_CASE(platformWin64);

TEST_CASE(platformUnix32);

TEST_CASE(platformUnix64);

TEST_CASE(platformWin32AStringCat); // ticket #5015

TEST_CASE(platformWin32WStringCat); // ticket #5015

TEST_CASE(simplifyMathFunctions); // ticket #5031

TEST_CASE(simplifyMathFunctions_sqrt);

TEST_CASE(simplifyMathFunctions_cbrt);

TEST_CASE(simplifyMathFunctions_exp);

TEST_CASE(simplifyMathFunctions_exp2);

TEST_CASE(simplifyMathFunctions_logb);

TEST_CASE(simplifyMathFunctions_log1p);

TEST_CASE(simplifyMathFunctions_ilogb);

TEST_CASE(simplifyMathFunctions_log10);

TEST_CASE(simplifyMathFunctions_log);

TEST_CASE(simplifyMathFunctions_log2);

TEST_CASE(simplifyMathFunctions_div);

TEST_CASE(simplifyMathFunctions_pow);

TEST_CASE(simplifyMathFunctions_islessgreater);

TEST_CASE(simplifyMathFunctions_islessequal);

TEST_CASE(simplifyMathFunctions_isless);

TEST_CASE(simplifyMathFunctions_isgreaterequal);

TEST_CASE(simplifyMathFunctions_isgreater);

TEST_CASE(simplifyMathFunctions_fmin);

TEST_CASE(simplifyMathFunctions_fmax);

TEST_CASE(simplifyMathFunctions_acosh);

TEST_CASE(simplifyMathFunctions_acos);

TEST_CASE(simplifyMathFunctions_cosh);

TEST_CASE(simplifyMathFunctions_cos);

TEST_CASE(simplifyMathFunctions_erfc);

TEST_CASE(simplifyMathFunctions_erf);

TEST_CASE(simplifyMathFunctions_sin);

TEST_CASE(simplifyMathFunctions_sinh);

TEST_CASE(simplifyMathFunctions_asin);

TEST_CASE(simplifyMathFunctions_asinh);

TEST_CASE(simplifyMathFunctions_tan);

TEST_CASE(simplifyMathFunctions_tanh);

TEST_CASE(simplifyMathFunctions_atan);

TEST_CASE(simplifyMathFunctions_atanh);

TEST_CASE(simplifyMathFunctions_expm1);

TEST_CASE(simplifyMathFunctions_fma);

TEST_CASE(simplifyMathExpressions); //ticket #1620

// AST data

TEST_CASE(astexpr);

TEST_CASE(astpar);

TEST_CASE(astbrackets);

TEST_CASE(astunaryop);

TEST_CASE(astfunction);

TEST_CASE(asttemplate);

}

std::string tokenizeAndStringify(const char code[], bool simplify = false, bool expand = true, Settings::PlatformType platform = Settings::Unspecified, const char* filename = "test.cpp", bool cpp11 = true) {

errout.str("");

Settings settings;

settings.debugwarnings = true;

settings.platform(platform);

settings.standards.cpp = cpp11 ? Standards::CPP11 : Standards::CPP03;

// tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

if (simplify)

tokenizer.simplifyTokenList2();

// filter out ValueFlow messages..

const std::string debugwarnings = errout.str();

errout.str("");

std::istringstream istr2(debugwarnings.c_str());

std::string line;

while (std::getline(istr2,line)) {

if (line.find("ValueFlow") == std::string::npos)

errout << line << "\n";

}

return tokenizer.tokens()->stringifyList(false, expand, false, true, false, 0, 0);

}

void tokenize1() {

const std::string code("void f ( )\n"

"{ if ( p . y ( ) > yof ) { } }");

ASSERT_EQUALS(code, tokenizeAndStringify(code.c_str()));

}

void tokenize2() {

const std::string code("{ sizeof a, sizeof b }");

ASSERT_EQUALS("{ sizeof ( a ) , sizeof ( b ) }", tokenizeAndStringify(code.c_str()));

}

void tokenize3() {

const std::string code("void foo()\n"

"{\n"

" int i;\n"

" ABC(for(i=0;i<10;i++) x());\n"

"}");

ASSERT_EQUALS("void foo ( )\n"

"{\n"

"int i ;\n"

"ABC ( for ( i = 0 ; i < 10 ; i ++ ) x ( ) ) ;\n"

"}", tokenizeAndStringify(code.c_str()));

ASSERT_EQUALS("", errout.str());

}

void tokenize4() {

const std::string code("class foo\n"

"{\n"

"public:\n"

" const int i;\n"

"}");

ASSERT_EQUALS("class foo\n"

"{\n"

"public:\n"

"const int i ;\n"

"}", tokenizeAndStringify(code.c_str()));

ASSERT_EQUALS("", errout.str());

}

void tokenize5() {

// Tokenize values

ASSERT_EQUALS("; + 1E3 ;", tokenizeAndStringify("; +1E3 ;"));

ASSERT_EQUALS("; 1E-2 ;", tokenizeAndStringify("; 1E-2 ;"));

}

void tokenize6() {

// "&p[1]" => "p+1"

/*

ASSERT_EQUALS("; x = p + n ;", tokenizeAndStringify("; x = & p [ n ] ;", true));

ASSERT_EQUALS("; x = ( p + n ) [ m ] ;", tokenizeAndStringify("; x = & p [ n ] [ m ] ;", true));

ASSERT_EQUALS("; x = y & p [ n ] ;", tokenizeAndStringify("; x = y & p [ n ] ;", true));

ASSERT_EQUALS("; x = 10 & p [ n ] ;", tokenizeAndStringify("; x = 10 & p [ n ] ;", true));

ASSERT_EQUALS("; x = y [ 10 ] & p [ n ] ;", tokenizeAndStringify("; x = y [ 10 ] & p [ n ] ;", true));

ASSERT_EQUALS("; x = ( a + m ) & p [ n ] ;", tokenizeAndStringify("; x = ( a + m ) & p [ n ] ;", true));*/

// "*(p+1)" => "p[1]"

ASSERT_EQUALS("; x = p [ 1 ] ;", tokenizeAndStringify("; x = * ( p + 1 ) ;", true));

ASSERT_EQUALS("; x = p [ 10 ] ;", tokenizeAndStringify("; x = * ( p + 0xA ) ;", true));

ASSERT_EQUALS("; x = p [ n ] ;", tokenizeAndStringify("; x = * ( p + n ) ;", true));

ASSERT_EQUALS("; x = y * ( p + n ) ;", tokenizeAndStringify("; x = y * ( p + n ) ;", true));

ASSERT_EQUALS("; x = 10 * ( p + n ) ;", tokenizeAndStringify("; x = 10 * ( p + n ) ;", true));

ASSERT_EQUALS("; x = y [ 10 ] * ( p + n ) ;", tokenizeAndStringify("; x = y [ 10 ] * ( p + n ) ;", true));

ASSERT_EQUALS("; x = ( a + m ) * ( p + n ) ;", tokenizeAndStringify("; x = ( a + m ) * ( p + n ) ;", true));

// "*(p-1)" => "p[-1]" and "*(p-n)" => "p[-n]"

ASSERT_EQUALS("; x = p [ -1 ] ;", tokenizeAndStringify("; x = *(p - 1);", true));

ASSERT_EQUALS("; x = p [ -10 ] ;", tokenizeAndStringify("; x = *(p - 0xA);", true));

ASSERT_EQUALS("; x = p [ - n ] ;", tokenizeAndStringify("; x = *(p - n);", true));

ASSERT_EQUALS("; x = y * ( p - 1 ) ;", tokenizeAndStringify("; x = y * (p - 1);", true));

ASSERT_EQUALS("; x = 10 * ( p - 1 ) ;", tokenizeAndStringify("; x = 10 * (p - 1);", true));

ASSERT_EQUALS("; x = y [ 10 ] * ( p - 1 ) ;", tokenizeAndStringify("; x = y[10] * (p - 1);", true));

ASSERT_EQUALS("; x = ( a - m ) * ( p - n ) ;", tokenizeAndStringify("; x = (a - m) * (p - n);", true));

// Test that the array-index simplification is not applied when there's no dereference:

// "(x-y)" => "(x-y)" and "(x+y)" => "(x+y)"

ASSERT_EQUALS("; a = b * ( x - y ) ;", tokenizeAndStringify("; a = b * (x - y);", true));

ASSERT_EQUALS("; a = b * x [ - y ] ;", tokenizeAndStringify("; a = b * *(x - y);", true));

ASSERT_EQUALS("; a = a * ( x - y ) ;", tokenizeAndStringify("; a *= (x - y);", true));

ASSERT_EQUALS("; z = a ++ * ( x - y ) ;", tokenizeAndStringify("; z = a++ * (x - y);", true));

ASSERT_EQUALS("; z = a ++ * ( x + y ) ;", tokenizeAndStringify("; z = a++ * (x + y);", true));

ASSERT_EQUALS("; z = a -- * ( x - y ) ;", tokenizeAndStringify("; z = a-- * (x - y);", true));

ASSERT_EQUALS("; z = a -- * ( x + y ) ;", tokenizeAndStringify("; z = a-- * (x + y);", true));

ASSERT_EQUALS("; z = 'a' * ( x - y ) ;", tokenizeAndStringify("; z = 'a' * (x - y);", true));

ASSERT_EQUALS("; z = \"a\" * ( x - y ) ;", tokenizeAndStringify("; z = \"a\" * (x - y);", true));

ASSERT_EQUALS("; z = 'a' * ( x + y ) ;", tokenizeAndStringify("; z = 'a' * (x + y);", true));

ASSERT_EQUALS("; z = \"a\" * ( x + y ) ;", tokenizeAndStringify("; z = \"a\" * (x + y);", true));

ASSERT_EQUALS("; z = foo ( ) * ( x + y ) ;", tokenizeAndStringify("; z = foo() * (x + y);", true));

}

void tokenize7() {

const std::string code = "void f() {\n"

" int x1 = 1;\n"

" int x2(x1);\n"

"}\n";

ASSERT_EQUALS("void f ( ) {\nint x1 ; x1 = 1 ;\nint x2 ; x2 = x1 ;\n}",

tokenizeAndStringify(code.c_str(), false));

}

void tokenize8() {

const std::string code = "void f() {\n"

" int x1(g());\n"

" int x2(x1);\n"

"}\n";

ASSERT_EQUALS("\n\n##file 0\n"

"1: void f ( ) {\n"

"2: int x1@1 ; x1@1 = g ( ) ;\n"

"3: int x2@2 ; x2@2 = x1@1 ;\n"

"4: }\n",

tokenizeDebugListing(code, false));

}

void tokenize9() {

const char code[] = "typedef void (*fp)();\n"

"typedef fp (*fpp)();\n"

"void f() {\n"

" fpp x = (fpp)f();\n"

"}";

tokenizeAndStringify(code, false);

ASSERT_EQUALS("", errout.str());

}

void tokenize10() {

ASSERT_EQUALS("private:", tokenizeAndStringify("private:", false));

ASSERT_EQUALS("protected:", tokenizeAndStringify("protected:", false));

ASSERT_EQUALS("public:", tokenizeAndStringify("public:", false));

ASSERT_EQUALS("__published:", tokenizeAndStringify("__published:", false));

}

void tokenize11() {

ASSERT_EQUALS("X * sizeof ( Y ( ) ) ;", tokenizeAndStringify("X * sizeof(Y());", false));

}

// ticket #2118 - invalid syntax error

void tokenize12() {

tokenizeAndStringify("Q_GLOBAL_STATIC_WITH_INITIALIZER(Qt4NodeStaticData, qt4NodeStaticData, {\n"

" for (unsigned i = 0 ; i < count; i++) {\n"

" }\n"

"});");

ASSERT_EQUALS("", errout.str());

}

// bailout if there is "@" - it is not handled well

void tokenize13() {

const char code[] = "@implementation\n"

"-(Foo *)foo: (Bar *)bar\n"

"{ }\n"

"@end\n";

ASSERT_EQUALS("", tokenizeAndStringify(code));

}

// Ticket #2361: 0X10 => 16

void tokenize14() {

ASSERT_EQUALS("; 16 ;", tokenizeAndStringify(";0x10;"));

ASSERT_EQUALS("; 16 ;", tokenizeAndStringify(";0X10;"));

ASSERT_EQUALS("; 292 ;", tokenizeAndStringify(";0444;"));

}

// Ticket #2429: 0.125

void tokenize15() {

ASSERT_EQUALS("0.125", tokenizeAndStringify(".125"));

ASSERT_EQUALS("005.125", tokenizeAndStringify("005.125")); // Don't confuse with octal values

}

// #2612 - segfault for "<><<"

void tokenize16() {

tokenizeAndStringify("<><<");

}

void tokenize17() { // #2759

ASSERT_EQUALS("class B : private :: A { } ;", tokenizeAndStringify("class B : private ::A { };"));

}

void tokenize18() { // tokenize "(X&&Y)" into "( X && Y )" instead of "( X & & Y )"

ASSERT_EQUALS("( X && Y )", tokenizeAndStringify("(X&&Y)"));

}

void tokenize19() {

// #3006 - added hasComplicatedSyntaxErrorsInTemplates to avoid segmentation fault

tokenizeAndStringify("x < () <");

// #3496 - make sure hasComplicatedSyntaxErrorsInTemplates works

ASSERT_EQUALS("void a ( Fred * f ) { for ( ; n < f . x ( ) ; ) { } }",

tokenizeAndStringify("void a(Fred* f) MACRO { for (;n < f->x();) {} }"));

}

void tokenize20() { // replace C99 _Bool => bool

ASSERT_EQUALS("bool a ; a = true ;", tokenizeAndStringify("_Bool a = true;"));

}

void tokenize21() { // tokenize 0x0E-7

ASSERT_EQUALS("14 - 7", tokenizeAndStringify("0x0E-7"));

}

void tokenize22() { // tokenize special marker $ from preprocessor

ASSERT_EQUALS("a $b", tokenizeAndStringify("a$b"));

ASSERT_EQUALS("a $b\nc", tokenizeAndStringify("a $b\nc"));

ASSERT_EQUALS("a = $0 ;", tokenizeAndStringify("a = $0;"));

ASSERT_EQUALS("a $++ ;", tokenizeAndStringify("a$++;"));

ASSERT_EQUALS("$if ( ! p )", tokenizeAndStringify("$if(!p)"));

}

// #4195 - segfault for "enum { int f ( ) { return = } r = f ( ) ; }"

void tokenize24() {

tokenizeAndStringify("enum { int f ( ) { return = } r = f ( ) ; }");

}

// #4239 - segfault for "f ( struct { int typedef T x ; } ) { }"

void tokenize25() {

tokenizeAndStringify("f ( struct { int typedef T x ; } ) { }");

}

// #4245 - segfault

void tokenize26() {

tokenizeAndStringify("class x { protected : template < int y = } ;");

}

// #4525 - segfault

void tokenize27() {

tokenizeAndStringify("struct except_spec_d_good : except_spec_a, except_spec_b {\n"

"~except_spec_d_good();\n"

"};\n"

"struct S { S(); };\n"

"S::S() __attribute((pure)) = default;"

);

}

// #4725 - ^{}

void tokenize28() {

ASSERT_EQUALS("void f ( ) { asm ( \"^{}\" ) ; }", tokenizeAndStringify("void f() { ^{} }"));

ASSERT_EQUALS("void f ( ) { asm ( \"x(^{})\" ) ; }", tokenizeAndStringify("void f() { x(^{}); }"));

ASSERT_EQUALS("; asm ( \"voidf^{return}intmain\" ) ; ( ) { }", tokenizeAndStringify("; void f ^ { return } int main ( ) { }"));

}

// #5506 - segmentation fault upon invalid code

void tokenize29() {

tokenizeAndStringify("A template < int { int = -1 ; } template < int N > struct B { int [ A < N > :: zero ] ; } ; B < 0 > b ;");

}

void wrong_syntax1() {

{

const std::string code("TR(kvmpio, PROTO(int rw), ARGS(rw), TP_(aa->rw;))");

ASSERT_EQUALS("TR ( kvmpio , PROTO ( int rw ) , ARGS ( rw ) , TP_ ( aa . rw ; ) )", tokenizeAndStringify(code.c_str(), true));

ASSERT_EQUALS("", errout.str());

}

{

const std::string code("struct A { template<int> struct { }; };");

ASSERT_EQUALS("", tokenizeAndStringify(code.c_str(), true));

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

}

{

const std::string code("enum ABC { A,B, typedef enum { C } };");

tokenizeAndStringify(code.c_str(), true);

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

}

{

// #3314 - don't report syntax error.

const std::string code("struct A { typedef B::C (A::*f)(); };");

tokenizeAndStringify(code.c_str(), true);

ASSERT_EQUALS("[test.cpp:1]: (debug) Failed to parse 'typedef B :: C ( A :: * f ) ( ) ;'. The checking continues anyway.\n", errout.str());

}

}

void wrong_syntax2() { // #3504

const char code[] = "void f() {\n"

" X<int> x;\n"

" Y<int, int, int, int, int, char> y;\n"

"}\n"

"\n"

"void G( template <typename T> class (j) ) {}";

// don't segfault..

tokenizeAndStringify(code);

}

void wrong_syntax3() { // #3544

const char code[] = "X #define\n"

"{\n"

" (\n"

" for( #endif typedef typedef cb[N] )\n"

" ca[N]; = cb[i]\n"

" )\n"

"}";

tokenizeAndStringify(code);

}

void wrong_syntax4() { // #3618

const char code[] = "typedef void (x) (int); return x&";

tokenizeAndStringify(code);

}

void wrong_syntax_if_macro() {

// #2518 #4171

tokenizeAndStringify("void f() { if MACRO(); }", false);

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

// #4668 - note there is no semicolon after MACRO()

tokenizeAndStringify("void f() { if (x) MACRO() {} }", false);

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

// #4810 - note there is no semicolon after MACRO()

tokenizeAndStringify("void f() { if (x) MACRO() else ; }", false);

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

}

void wrong_syntax_class_x_y() {

// #3585

const char code[] = "class x y { };";

errout.str("");

Settings settings;

settings.addEnabled("information");

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.c");

tokenizer.simplifyTokenList2();

ASSERT_EQUALS("[test.c:1]: (information) The code 'class x y {' is not handled. You can use -I or --include to add handling of this code.\n", errout.str());

}

void syntax_case_default() {

//correct syntax

{

tokenizeAndStringify("void f() {switch (n) { case 0: z(); break;}}");

ASSERT_EQUALS("", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0:; break;}}");

ASSERT_EQUALS("", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0?1:2 : z(); break;}}");

ASSERT_EQUALS("", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0?(1?3:4):2 : z(); break;}}");

ASSERT_EQUALS("", errout.str());

//allow GCC '({ %var%|%num%|%bool% ; })' statement expression extension

tokenizeAndStringify("void f() {switch (n) { case 0?({0;}):1: z(); break;}}");

ASSERT_EQUALS("", errout.str());

//'b' can be or a macro or an undefined enum

tokenizeAndStringify("void f() {switch (n) { case b: z(); break;}}");

ASSERT_EQUALS("", errout.str());

//valid, when there's this declaration: 'constexpr int g() { return 2; }'

tokenizeAndStringify("void f() {switch (n) { case g(): z(); break;}}");

ASSERT_EQUALS("", errout.str());

//valid, when there's also this declaration: 'constexpr int g[1] = {0};'

tokenizeAndStringify("void f() {switch (n) { case g[0]: z(); break;}}");

ASSERT_EQUALS("", errout.str());

//valid, similar to above case

tokenizeAndStringify("void f() {switch (n) { case *g: z(); break;}}");

ASSERT_EQUALS("", errout.str());

//valid, when 'x' and 'y' are constexpr.

tokenizeAndStringify("void f() {switch (n) { case sqrt(x+y): z(); break;}}");

ASSERT_EQUALS("", errout.str());

}

//wrong syntax

{

tokenizeAndStringify("void f() {switch (n) { case: z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

tokenizeAndStringify("void f() {switch (n) { case;: z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

tokenizeAndStringify("void f() {switch (n) { case {}: z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0?{1}:{2} : z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0?1;:{2} : z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

tokenizeAndStringify("void f() {switch (n) { case 0?(1?{3:4}):2 : z(); break;}}");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

//ticket #4234

tokenizeAndStringify("( ) { switch break ; { switch ( x ) { case } y break ; : } }");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

//ticket #4267

tokenizeAndStringify("f ( ) { switch break; { switch ( x ) { case } case break; -6: ( ) ; } }");

ASSERT_EQUALS("[test.cpp:1]: (error) syntax error\n", errout.str());

}

}

void garbageCode1() {

tokenizeAndStringify("struct x foo_t; foo_t typedef y;");

}

void garbageCode2() { //#4300 (segmentation fault)

tokenizeAndStringify("enum { D = 1 struct { } ; } s.b = D;");

}

void garbageCode3() { //#4849 (segmentation fault in Tokenizer::simplifyStructDecl (invalid code))

tokenizeAndStringify("enum { D = 2 s ; struct y { x } ; } { s.a = C ; s.b = D ; }");