/*

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

* Copyright (C) 2007-2011 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 <cstring>

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 "<><<"

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

TEST_CASE(wrong_syntax);

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

TEST_CASE(minus);

TEST_CASE(longtok);

TEST_CASE(removeCast1);

TEST_CASE(removeCast2);

TEST_CASE(removeCast3);

TEST_CASE(removeCast4);

TEST_CASE(removeCast5);

TEST_CASE(removeCast6);

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(whileAddBraces);

TEST_CASE(doWhileAddBraces);

TEST_CASE(forAddBraces);

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(simplifyKnownVariablesBailOutAssign);

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(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(varid21);

TEST_CASE(varid22);

TEST_CASE(varid23);

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(varidFunctionCall1);

TEST_CASE(varidFunctionCall2);

TEST_CASE(varidFunctionCall3);

TEST_CASE(varidStl);

TEST_CASE(varid_delete);

TEST_CASE(varid_functions);

TEST_CASE(varid_reference_to_containers);

TEST_CASE(varid_in_class1);

TEST_CASE(varid_in_class2);

TEST_CASE(varid_operator);

TEST_CASE(varid_throw);

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(file1);

TEST_CASE(file2);

TEST_CASE(file3);

TEST_CASE(doublesharp);

TEST_CASE(macrodoublesharp);

TEST_CASE(simplify_function_parameters);

TEST_CASE(removeParantheses1); // Ticket #61

TEST_CASE(removeParantheses2);

TEST_CASE(removeParantheses3);

TEST_CASE(removeParantheses4); // Ticket #390

TEST_CASE(removeParantheses5); // Ticket #392

TEST_CASE(removeParantheses6);

TEST_CASE(removeParantheses7);

TEST_CASE(removeParantheses8); // Ticket #1865

TEST_CASE(removeParantheses9); // Ticket #1962

TEST_CASE(removeParantheses10); // Ticket #2320

TEST_CASE(removeParantheses11); // Ticket #2505

TEST_CASE(tokenize_double);

TEST_CASE(tokenize_strings);

TEST_CASE(simplify_constants);

TEST_CASE(simplify_constants2);

TEST_CASE(simplify_constants3);

TEST_CASE(simplify_null);

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(vardecl_stl_1);

TEST_CASE(vardecl_stl_2);

TEST_CASE(vardecl_template);

TEST_CASE(vardecl_union);

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(createLinks);

TEST_CASE(signed1);

TEST_CASE(removeExceptionSpecification1);

TEST_CASE(removeExceptionSpecification2);

TEST_CASE(removeExceptionSpecification3);

TEST_CASE(gt); // use "<" comparisons instead of ">"

TEST_CASE(simplifyString);

TEST_CASE(simplifyConst);

TEST_CASE(switchCase);

TEST_CASE(functionpointer);

TEST_CASE(removeRedundantAssignment);

TEST_CASE(removedeclspec);

TEST_CASE(removeattribute);

TEST_CASE(cpp0xtemplate1);

TEST_CASE(cpp0xtemplate2);

TEST_CASE(cpp0xtemplate3);

TEST_CASE(cpp0xdefault);

TEST_CASE(arraySize);

TEST_CASE(labels);

TEST_CASE(simplifyInitVar);

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(microsoftMFC);

TEST_CASE(borland);

TEST_CASE(Qt);

TEST_CASE(sql);

TEST_CASE(simplifyLogicalOperators);

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

TEST_CASE(simplifyAssignmentInFunctionCall);

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

TEST_CASE(simplifyCompoundAssignment);

// Tokenize C#

TEST_CASE(cs);

// Tokenize JAVA

TEST_CASE(java);

TEST_CASE(simplifyOperatorName1);

TEST_CASE(simplifyOperatorName2);

TEST_CASE(simplifyOperatorName3);

TEST_CASE(simplifyOperatorName4);

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

TEST_CASE(removeMacrosInGlobalScope);

}

bool cmptok(const char *expected[], const Token *actual)

{

unsigned int i = 0;

for (; expected[i] && actual; ++i, actual = actual->next())

{

if (strcmp(expected[i], actual->str().c_str()) != 0)

return false;

}

return (expected[i] == NULL && actual == NULL);

}

std::string tokenizeAndStringify(const char code[], bool simplify = false)

{

errout.str("");

Settings settings;

settings.debugwarnings = true;

// tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

if (simplify)

tokenizer.simplifyTokenList();

std::ostringstream ostr;

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next())

{

if (!simplify)

{

if (tok->isUnsigned())

ostr << "unsigned ";

else if (tok->isSigned())

ostr << "signed ";

}

if (tok->isLong())

ostr << "long ";

ostr << tok->str();

// Append newlines

if (tok->next())

{

if (tok->linenr() != tok->next()->linenr())

{

for (unsigned int i = tok->linenr(); i < tok->next()->linenr(); ++i)

ostr << "\n";

}

else

{

ostr << " ";

}

}

}

return ostr.str();

}

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()

{

errout.str("");

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()

{

errout.str("");

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 [ 1 ] ;", tokenizeAndStringify("; x = * ( p + 1 ) ;", true));

ASSERT_EQUALS("; x = p [ n ] ;", tokenizeAndStringify("; x = * ( p + n ) ;", 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.c_str(), false));

}

void tokenize9()

{

errout.str("");

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;"));

}

// Ticket #2429: 0.125

void tokenize15()

{

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

}

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

void tokenize16()

{

tokenizeAndStringify("<><<");

}

void wrong_syntax()

{

{

errout.str("");

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());

}

{

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());

}

{

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());

}

}

void wrong_syntax_if_macro()

{

// #2518

errout.str("");

const std::string code("void f() { if MACRO(); }");

tokenizeAndStringify(code.c_str(), false);

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

}

void minus()

{

ASSERT_EQUALS("i = -12", tokenizeAndStringify("i = -12"));

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

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

ASSERT_EQUALS("int f ( ) { return -2 ; }", tokenizeAndStringify("int f(){return -2;}"));

}

void longtok()

{

std::string filedata(10000, 'a');

errout.str("");

Settings settings;

// tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(filedata);

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

// Expected result..

ASSERT_EQUALS(std::string(10000, 'a'), tokenizer.tokens()->str());

}

// Don’t remove "(int *)"..

void removeCast1()

{

const char code[] = "int *f(int *);";

errout.str("");

Settings settings;

// tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyCasts();

std::ostringstream ostr;

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next())

ostr << " " << tok->str();

ASSERT_EQUALS(" int * f ( int * ) ;", ostr.str());

}

// remove static_cast..

void removeCast2()

{

const char code[] = "t = (static_cast<std::vector<int> *>(&p));\n";

errout.str("");

Settings settings;

// tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyCasts();

std::ostringstream ostr;

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next())

ostr << " " << tok->str();

ASSERT_EQUALS(" t = & p ;", ostr.str());

}

void removeCast3()

{

// ticket #961

const char code[] = "assert (iplen >= (unsigned) ipv4->ip_hl * 4 + 20);";

const char expected[] = "assert ( iplen >= ipv4 . ip_hl * 4 + 20 ) ;";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void removeCast4()

{

// ticket #970

const char code[] = "if (a >= (unsigned)(b)) {}";

const char expected[] = "if ( a >= ( int ) b ) { }";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void removeCast5()

{

// ticket #1817

ASSERT_EQUALS("a . data = f ;", tokenizeAndStringify("a->data = reinterpret_cast<void*>(static_cast<intptr_t>(f));", true));

}

void removeCast6()

{

// ticket #2103

ASSERT_EQUALS("if ( ! x )", tokenizeAndStringify("if (x == (char *) ((void *)0))", true));

}

void inlineasm()

{

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";asm { mov ax,bx };"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";_asm { mov ax,bx };"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";__asm { mov ax,bx };"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";__asm__ __volatile__ ( \"mov ax,bx\" );"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";__asm _emit 12h ;"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";__asm mov a, b ;"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";asm volatile (\"fnstcw %0\" : \"= m\" (old_cw));"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify("; __asm__ (\"fnstcw %0\" : \"= m\" (old_cw));"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify("; __asm __volatile__ (\"ddd\") ;"));

ASSERT_EQUALS("; asm ( ) ;", tokenizeAndStringify(";__asm__ volatile ( \"mov ax,bx\" );"));

}

void pointers_condition()

{

ASSERT_EQUALS("( p )", tokenizeAndStringify("( p != NULL )", true));

ASSERT_EQUALS("( p )", tokenizeAndStringify("( NULL != p )", true));

ASSERT_EQUALS("( this . p )", tokenizeAndStringify("( this->p != NULL )", true));

ASSERT_EQUALS("( this . p )", tokenizeAndStringify("( NULL != this->p )", true));

ASSERT_EQUALS("( Foo :: p )", tokenizeAndStringify("( Foo::p != NULL )", true));

ASSERT_EQUALS("( Foo :: p )", tokenizeAndStringify("( NULL != Foo::p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == NULL )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( NULL == p )", true));

ASSERT_EQUALS("( ! this . p )", tokenizeAndStringify("( this->p == NULL )", true));

ASSERT_EQUALS("( ! this . p )", tokenizeAndStringify("( NULL == this->p )", true));

ASSERT_EQUALS("( ! Foo :: p )", tokenizeAndStringify("( Foo::p == NULL )", true));

ASSERT_EQUALS("( ! Foo :: p )", tokenizeAndStringify("( NULL == Foo::p )", true));

ASSERT_EQUALS("( p1 || ! p2 )", tokenizeAndStringify("( p1 != NULL || p2 == NULL )", true));

ASSERT_EQUALS("( p1 && ! p2 )", tokenizeAndStringify("( p1 != NULL && p2 == NULL )", true));

ASSERT_EQUALS("a & & b", tokenizeAndStringify("a & &b", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == false )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == 0 )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == '\\0' )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == 0L )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == 0UL )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == 0ul )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( p == 0l )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( false == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( 0 == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( '\\0' == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( 0L == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( 0UL == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( 0ul == p )", true));

ASSERT_EQUALS("( ! p )", tokenizeAndStringify("( 0l == p )", true));

}

void ifAddBraces1()

{

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

"{\n"

" if (a);\n"

" else ;\n"

"}\n";

ASSERT_EQUALS("void f ( )\n"

"{\n"

"if ( a ) { ; }\n"

"else { ; }\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces2()

{

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

"{\n"

" if (a) if (b) { }\n"

"}\n";

ASSERT_EQUALS("void f ( )\n"

"{\n"

"if ( a ) { if ( b ) { } }\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces3()

{

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

"{\n"

" if (a) for (;;) { }\n"

"}\n";

ASSERT_EQUALS("void f ( )\n"

"{\n"

"if ( a ) { for ( ; ; ) { } }\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces4()

{

const char code[] = "char * foo ()\n"

"{\n"

" char *str = malloc(10);\n"

" if (somecondition)\n"

" for ( ; ; )\n"

" { }\n"

" return str;\n"

"}\n";

ASSERT_EQUALS("char * foo ( )\n"

"{\n"

"char * str ; str = malloc ( 10 ) ;\n"

"if ( somecondition ) {\n"

"for ( ; ; )\n"

"{ } }\n"

"return str ;\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces5()

{

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

"{\n"

"for(int i = 0; i < 2; i++)\n"

"if(true)\n"

"return;\n"

"\n"

"return;\n"

"}\n";

ASSERT_EQUALS("void f ( )\n"

"{\n"

"for ( int i = 0 ; i < 2 ; i ++ ) {\n"

"{\n"

"return ; } }\n\n"

"return ;\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces6()

{

const char code[] = "if()";

ASSERT_EQUALS("if ( )", tokenizeAndStringify(code, true));

}

void ifAddBraces7()

{

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

"{\n"

"int a;\n"

"if( a )\n"

" ({a=4;}),({a=5;});\n"

"}\n";

ASSERT_EQUALS("void f ( )\n"

"{\n"

"int a ;\n"

"if ( a ) {\n"

"( { a = 4 ; } ) , ( { a = 5 ; } ) ; }\n"

"}", tokenizeAndStringify(code, true));

}

void ifAddBraces9()

{

// ticket #990

const char code[] =

"void f() {"

" for (int k=0; k<VectorSize; k++)"

" LOG_OUT(ID_Vector[k])"

"}";

const char expected[] =

"void f ( ) { "

"for ( int k = 0 ; k < VectorSize ; k ++ ) { "

"LOG_OUT ( ID_Vector [ k ] ) "

"} "

"}";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void ifAddBraces10()

{

// ticket #1361

const char code[] = "{ DEBUG(if (x) y; else z); }";

const char expected[] = "{ DEBUG ( if ( x ) y ; else z ) ; }";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void ifAddBraces11()

{

const char code[] = "{ if (x) if (y) ; else ; }";

const char expected[] = "{ if ( x ) { if ( y ) { ; } else { ; } } }";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void ifAddBraces12()

{

// ticket #1424

const char code[] = "{ if (x) do { } while(x); }";

const char expected[] = "{ if ( x ) { do { } while ( x ) ; } }";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

void ifAddBraces13()

{

// ticket #1809

const char code[] = "{ if (x) if (y) { } else { } else { } }";

const char expected[] = "{ if ( x ) { if ( y ) { } else { } } else { } }";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

// ticket #1809

const char code2[] = "{ if (x) while (y) { } else { } }";

const char expected2[] = "{ if ( x ) { while ( y ) { } } else { } }";

ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, true));

}

void ifAddBraces14()

{

// ticket #2610 (segfault)

tokenizeAndStringify("if()<{}", false);

}

void ifAddBraces15()

{

// ticket #2616 - unknown macro before if

ASSERT_EQUALS("{ A if ( x ) { y ( ) ; } }", tokenizeAndStringify("{A if(x)y();}", false));

}

void whileAddBraces()

{

const char code[] = ";while(a);";

ASSERT_EQUALS("; while ( a ) { ; }", tokenizeAndStringify(code, true));

}

void doWhileAddBraces()

{

{

const char code[] = "do ; while (0);";

const char result[] = "do { ; } while ( 0 ) ;";

ASSERT_EQUALS(result, tokenizeAndStringify(code, false));

}

{

const char code[] = "UNKNOWN_MACRO ( do ) ; while ( a -- ) ;";

const char result[] = "UNKNOWN_MACRO ( do ) ; while ( a -- ) { ; }";

ASSERT_EQUALS(result, tokenizeAndStringify(code, true));

}

{

const char code[] = "UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) ;";

const char result[] = "UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) { ; }";

ASSERT_EQUALS(result, tokenizeAndStringify(code, true));

}

{

const char code[] = "void foo ( int c , int d ) {\n"

" do\n"

" if ( c ) {\n"

" while ( c ) { c -- ; }\n"

" }\n"

" while ( -- d > 0 ) ;\n"

" return 0 ;\n"

"}\n";

const char result[] = "void foo ( int c , int d ) {\n"

"do {\n"

"if ( c ) {\n"

"while ( c ) { c -- ; }\n"

"} }\n"

"while ( -- d > 0 ) ;\n"

"return 0 ;\n"

"}";

ASSERT_EQUALS(result, tokenizeAndStringify(code, true));

}

{

const char code[] = "void foo ( int c , int d ) {\n"

" do\n"

" do c -- ; while ( c ) ;\n"

" while ( -- d > 0 ) ;\n"

" return 0 ;\n"

"}\n";

const char result[] = "void foo ( int c , int d ) {\n"

"do {\n"

"do { c -- ; } while ( c ) ; }\n"

"while ( -- d > 0 ) ;\n"

"return 0 ;\n"

"}";

ASSERT_EQUALS(result, tokenizeAndStringify(code, true));

}

}

void forAddBraces()

{

{

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

" for(;;)\n"

" if (a) { }\n"

" else { }\n"

"}";

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

"for ( ; ; ) {\n"

"if ( a ) { }\n"

"else { } }\n"

"}";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

{

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

" for(;;)\n"

" if (a) { }\n"

" else if (b) { }\n"

" else { }\n"

"}";

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

"for ( ; ; ) {\n"

"if ( a ) { }\n"

"else { if ( b ) { }\n"

"else { } } }\n"

"}";

ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));

}

}

std::string simplifyKnownVariables(const char code[])

{

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.setVarId();

tokenizer.simplifyKnownVariables();

std::ostringstream ostr;

for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next())

{

if (tok->previous())

ostr << " ";

ostr << tok->str();

}