TestSimplifyTokens() : TestFixture("TestSimplifyTokens") {

}

Settings settings_std;

Settings settings_windows;

void run() {

LOAD_LIB_2(settings_std.library, "std.cfg");

LOAD_LIB_2(settings_windows.library, "windows.cfg");

// Make sure the Tokenizer::simplifyTokenList works.

// The order of the simplifications is important. So this test

// case shall make sure the simplifications are done in the

// correct order

TEST_CASE(simplifyTokenList1);

TEST_CASE(cast);

TEST_CASE(iftruefalse);

TEST_CASE(combine_strings);

TEST_CASE(double_plus);

TEST_CASE(redundant_plus);

TEST_CASE(redundant_plus_numbers);

TEST_CASE(parentheses1);

TEST_CASE(parenthesesVar); // Remove redundant parentheses around variable .. "( %var% )"

TEST_CASE(declareVar);

TEST_CASE(declareArray);

TEST_CASE(dontRemoveIncrement);

TEST_CASE(removePostIncrement);

TEST_CASE(removePreIncrement);

TEST_CASE(elseif1);

TEST_CASE(ifa_ifa); // "if (a) { if (a) .." => "if (a) { if (1) .."

TEST_CASE(sizeof_array);

TEST_CASE(sizeof5);

TEST_CASE(sizeof6);

TEST_CASE(sizeof7);

TEST_CASE(sizeof8);

TEST_CASE(sizeof9);

TEST_CASE(sizeof10);

TEST_CASE(sizeof11);

TEST_CASE(sizeof12);

TEST_CASE(sizeof13);

TEST_CASE(sizeof14);

TEST_CASE(sizeof15);

TEST_CASE(sizeof16);

TEST_CASE(sizeof17);

TEST_CASE(sizeof18);

TEST_CASE(sizeof19); // #1891 - sizeof 'x'

TEST_CASE(sizeof20); // #2024 - sizeof a)

TEST_CASE(sizeof21); // #2232 - sizeof...(Args)

TEST_CASE(sizeof22); // #2599

TEST_CASE(sizeof23); // #2604

TEST_CASE(sizeofsizeof);

TEST_CASE(casting);

TEST_CASE(strlen1);

TEST_CASE(strlen2);

TEST_CASE(namespaces);

// Assignment in condition..

TEST_CASE(ifassign1);

TEST_CASE(ifAssignWithCast);

TEST_CASE(whileAssign1);

TEST_CASE(whileAssign2);

TEST_CASE(whileAssign3); // varid

TEST_CASE(whileAssign4); // links

TEST_CASE(doWhileAssign); // varid

TEST_CASE(test_4881); // similar to doWhileAssign (#4911), taken from #4881 with full code

// "if(0==x)" => "if(!x)"

TEST_CASE(ifnot);

TEST_CASE(combine_wstrings);

// Simplify "not" to "!" (#345)

TEST_CASE(not1);

// Simplify "and" to "&&" (#620)

TEST_CASE(and1);

// Simplify "or" to "||"

TEST_CASE(or1);

TEST_CASE(cAlternativeTokens);

TEST_CASE(comma_keyword);

TEST_CASE(remove_comma);

// Simplify "?:"

TEST_CASE(simplifyConditionOperator);

// Simplify calculations

TEST_CASE(calculations);

TEST_CASE(comparisons);

//remove dead code after flow control statements

TEST_CASE(simplifyFlowControl);

TEST_CASE(flowControl);

// Simplify nested strcat() calls

TEST_CASE(strcat1);

TEST_CASE(strcat2);

TEST_CASE(simplifyAtol)

TEST_CASE(simplifyOperator1);

TEST_CASE(reverseArraySyntax)

TEST_CASE(simplify_numeric_condition)

TEST_CASE(simplify_condition);

TEST_CASE(pointeralias1);

TEST_CASE(pointeralias2);

TEST_CASE(pointeralias3);

TEST_CASE(pointeralias4);

TEST_CASE(pointeralias5);

TEST_CASE(reduceConstness);

// simplify "while (0)"

TEST_CASE(while0);

// ticket #3140

TEST_CASE(while0for);

TEST_CASE(while1);

TEST_CASE(enum1);

TEST_CASE(enum2);

TEST_CASE(enum3);

TEST_CASE(enum4);

TEST_CASE(enum5);

TEST_CASE(enum6);

TEST_CASE(enum7);

TEST_CASE(enum8);

TEST_CASE(enum9); // ticket 1404

TEST_CASE(enum10); // ticket 1445

TEST_CASE(enum11);

TEST_CASE(enum12);

TEST_CASE(enum13);

TEST_CASE(enum14);

TEST_CASE(enum15);

TEST_CASE(enum16); // ticket #1988

TEST_CASE(enum17); // ticket #2381 (duplicate enums)

TEST_CASE(enum18); // #2466 (array with same name as enum constant)

TEST_CASE(enum19); // ticket #2536

TEST_CASE(enum20); // ticket #2600

TEST_CASE(enum21); // ticket #2720

TEST_CASE(enum22); // ticket #2745

TEST_CASE(enum23); // ticket #2804

TEST_CASE(enum24); // ticket #2828

TEST_CASE(enum25); // ticket #2966

TEST_CASE(enum26); // ticket #2975 (segmentation fault)

TEST_CASE(enum27); // ticket #3005 (segmentation fault)

TEST_CASE(enum28);

TEST_CASE(enum29); // ticket #3747 (bitwise or value)

TEST_CASE(enum30); // ticket #3852 (false positive)

TEST_CASE(enum31); // ticket #3934 (calculation in first item)

TEST_CASE(enum32); // ticket #3998 (access violation)

TEST_CASE(enum33); // ticket #4015 (segmentation fault)

TEST_CASE(enum34); // ticket #4141 (division by zero)

TEST_CASE(enum35); // ticket #3953 (avoid simplification of type)

TEST_CASE(enum36); // ticket #4378

TEST_CASE(enum37); // ticket #4280 (shadow variable)

TEST_CASE(enum38); // ticket #4463 (when throwing enum id, don't warn about shadow variable)

TEST_CASE(enum39); // ticket #5145 (fp variable hides enum)

TEST_CASE(enum40);

TEST_CASE(enum41); // ticket #5212 (valgrind errors during enum simplification)

TEST_CASE(enum42); // ticket #5182 (template function call in enum value)

TEST_CASE(enum43); // lhs in assignment

TEST_CASE(enumscope1); // ticket #3949

TEST_CASE(duplicateDefinition); // ticket #3565

TEST_CASE(invalid_enum); // #5600

// remove "std::" on some standard functions

TEST_CASE(removestd);

// Tokenizer::simplifyInitVar

TEST_CASE(simplifyInitVar);

// Tokenizer::simplifyReference

TEST_CASE(simplifyReference);

// x = realloc(y,0); => free(y);x=0;

TEST_CASE(simplifyRealloc);

// while(f() && errno==EINTR) { } => while (f()) { }

TEST_CASE(simplifyErrNoInWhile);

// while(fclose(f)); => r = fclose(f); while(r){r=fclose(f);}

TEST_CASE(simplifyFuncInWhile);

// struct ABC abc = { .a = 3 }; => struct ABC abc; abc.a = 3;

TEST_CASE(initstruct);

// struct ABC { } abc; => struct ABC { }; ABC abc;

TEST_CASE(simplifyStructDecl1);

TEST_CASE(simplifyStructDecl2); // ticket #2579

TEST_CASE(simplifyStructDecl3);

TEST_CASE(simplifyStructDecl4);

TEST_CASE(simplifyStructDecl5); // ticket #3533 (segmentation fault)

TEST_CASE(simplifyStructDecl6); // ticket #3732

TEST_CASE(simplifyStructDecl7); // ticket #476 (static anonymous struct array)

// register int var; => int var;

// inline int foo() {} => int foo() {}

TEST_CASE(removeUnwantedKeywords);

// remove calling convention __cdecl, __stdcall, ...

TEST_CASE(simplifyCallingConvention);

TEST_CASE(simplifyFunctorCall);

TEST_CASE(simplifyFunctionPointer); // ticket #5339 (simplify function pointer after comma)

TEST_CASE(redundant_semicolon);

TEST_CASE(simplifyFunctionReturn);

// void foo(void) -> void foo()

TEST_CASE(removeVoidFromFunction);

TEST_CASE(removeUnnecessaryQualification1);

TEST_CASE(removeUnnecessaryQualification2);

TEST_CASE(removeUnnecessaryQualification3);

TEST_CASE(removeUnnecessaryQualification4);

TEST_CASE(removeUnnecessaryQualification5);

TEST_CASE(removeUnnecessaryQualification6); // ticket #2859

TEST_CASE(removeUnnecessaryQualification7); // ticket #2970

TEST_CASE(removeUnnecessaryQualification8);

TEST_CASE(removeUnnecessaryQualification9); // ticket #3151

TEST_CASE(removeUnnecessaryQualification10); // ticket #3310 segmentation fault

TEST_CASE(simplifyIfNotNull);

TEST_CASE(simplifyVarDecl1); // ticket # 2682 segmentation fault

TEST_CASE(simplifyVarDecl2); // ticket # 2834 segmentation fault

TEST_CASE(return_strncat); // ticket # 2860 Returning value of strncat() reported as memory leak

// #3069 : for loop with 1 iteration

// for (x=0;x<1;x++) { .. }

// The for is redundant

TEST_CASE(removeRedundantFor);

TEST_CASE(consecutiveBraces);

TEST_CASE(undefinedSizeArray);

TEST_CASE(simplifyArrayAddress); // Replace "&str[num]" => "(str + num)"

TEST_CASE(simplifyCharAt);

TEST_CASE(simplifyOverride); // ticket #5069

}

std::string tok(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Unspecified) {

errout.str("");

Settings settings;

settings.addEnabled("portability");

settings.platform(type);

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

if (simplify)

tokenizer.simplifyTokenList2();

return tokenizer.tokens()->stringifyList(0, !simplify);

}

std::string tokWithWindows(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Unspecified) {

errout.str("");

settings_windows.addEnabled("portability");

settings_windows.platform(type);

Tokenizer tokenizer(&settings_windows, this);

std::istringstream istr(code);

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

if (simplify)

tokenizer.simplifyTokenList2();

return tokenizer.tokens()->stringifyList(0, !simplify);

}

std::string tok(const char code[], const char filename[], bool simplify = true) {

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

if (simplify)

tokenizer.simplifyTokenList2();

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

}

std::string tokWithStdLib(const char code[]) {

errout.str("");

Tokenizer tokenizer(&settings_std, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList2();

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

}

std::string tokenizeDebugListing(const char code[], bool simplify = false, const char filename[] = "test.cpp") {

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

if (simplify)

tokenizer.simplifyTokenList2();

// result..

return tokenizer.tokens()->stringifyList(true);

}

void simplifyTokenList1() {

// #1717 : The simplifyErrNoInWhile needs to be used before simplifyIfAndWhileAssign..

ASSERT_EQUALS("; x = f ( ) ; while ( x == -1 ) { x = f ( ) ; }",

tok(";while((x=f())==-1 && errno==EINTR){}",true));

}

void cast() {

ASSERT_EQUALS("if ( ! p ) { ; }", tok("if (p == (char *)0);"));

ASSERT_EQUALS("return str ;", tok("return (char *)str;"));

ASSERT_EQUALS("if ( * a )", tok("if ((char)*a)"));

ASSERT_EQUALS("if ( & a )", tok("if ((int)&a)"));

ASSERT_EQUALS("if ( * a )", tok("if ((unsigned int)(unsigned char)*a)"));

ASSERT_EQUALS("class A { A operator* ( int ) ; } ;", tok("class A { A operator *(int); };"));

ASSERT_EQUALS("class A { A operator* ( int ) const ; } ;", tok("class A { A operator *(int) const; };"));

ASSERT_EQUALS("if ( ! p ) { ; }", tok("if (p == (char *)(char *)0);"));

// no simplification as the cast may be important here. see #2897 for example

ASSERT_EQUALS("; * ( ( char * ) p + 1 ) = 0 ;", tok("; *((char *)p + 1) = 0;"));

ASSERT_EQUALS("if ( true )", tok("if ((unsigned char)1)")); // #4164

ASSERT_EQUALS("f ( 200 )", tok("f((unsigned char)200)"));

ASSERT_EQUALS("f ( ( char ) 1234 )", tok("f((char)1234)")); // dont simplify downcast

}

void iftruefalse() {

{

const char code1[] = " void f() { int a; bool use = false; if( use ) { a=0; } else {a=1;} }";

const char code2[] = " void f() { int a; bool use = false; {a=1;} }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; bool use = true; if( use ) { a=0; } else {a=1;} }";

const char code2[] = " void f() { int a; bool use = true; { a=0; } }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; int use = 5; if( use ) { a=0; } else {a=1;} }";

const char code2[] = " void f() { int a; int use = 5; { a=0; } }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; int use = 0; if( use ) { a=0; } else {a=1;} }";

const char code2[] = " void f() { int a; int use = 0; {a=1;} }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else a=1; int c=1; }";

const char code2[] = " void f() { int a; bool use = false; { a=1; } int c=1; }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else a=1; int c=1; }";

const char code2[] = " void f() { int a; bool use = true; { a=0; } int c=1; }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else if( bb ) a=1; int c=1; }";

const char code2[] = " void f ( ) { int a ; bool use ; use = false ; { if ( bb ) { a = 1 ; } } int c ; c = 1 ; }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; int c=1; }";

const char code2[] = " void f() { int a; bool use = true; { a=0;} int c=1; }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = "void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; else if( cc ) a=33; else { gg = 0; } int c=1; }";

const char code2[] = "void f ( ) { }";

ASSERT_EQUALS(code2, tok(code1));

}

{

const char code1[] = " void f() { if( aa ) { a=0; } else if( true ) a=1; else { a=2; } }";

const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 1 ; } } }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = " void f() { if( aa ) { a=0; } else if( false ) a=1; else { a=2; } }";

const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 2 ; } } }";

ASSERT_EQUALS(tok(code2), tok(code1));

}

{

const char code1[] = "static const int x=1; void f() { if(x) { a=0; } }";

ASSERT_EQUALS("void f ( ) { a = 0 ; }", tok(code1));

}

}

void combine_strings() {

const char code1[] = "void foo()\n"

"{\n"

"const char *a =\n"

"{\n"

"\"hello \"\n"

"\"world\"\n"

"};\n"

"}\n";

const char code2[] = "void foo()\n"

"{\n"

"const char *a =\n"

"{\n"

"\"hello world\"\n"

"};\n"

"}\n";

ASSERT_EQUALS(tok(code2), tok(code1));

}

void combine_wstrings() {

const char code1[] = "void foo()\n"

"{\n"

"const wchar_t *a =\n"

"{\n"

"L\"hello \"\n"

"L\"world\"\n"

"};\n"

"}\n";

const char code2[] = "void foo()\n"

"{\n"

"const wchar_t *a =\n"

"{\n"

"\"hello world\"\n"

"};\n"

"}\n";

Settings settings;

settings.platform(Settings::Unspecified);

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code1);

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

ASSERT_EQUALS(tok(code2), tokenizer.tokens()->stringifyList(0, false));

ASSERT_EQUALS(true, tokenizer.tokens()->tokAt(13) && tokenizer.tokens()->tokAt(13)->isLong());

}

void double_plus() {

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a++;\n"

"a--;\n"

"++a;\n"

"--a;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a ++ ; a -- ; ++ a ; -- a ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a+a;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a + a ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a+++b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a---b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- - b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a--+b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a++-b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ - b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a+--b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a + -- b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a-++b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a - ++ b ; }", tok(code1));

}

}

void redundant_plus() {

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a + + b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a + + + b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a + - b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a - + b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a - - b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a - + - b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));

}

{

const char code1[] = "void foo( int a, int b )\n"

"{\n"

"a=a - - - b;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));

}

}

void redundant_plus_numbers() {

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a + + 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a + + + 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a + - 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a - + 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a - - 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a - + - 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));

}

{

const char code1[] = "void foo( int a )\n"

"{\n"

"a=a - - - 1;\n"

"}\n";

ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));

}

}

void parentheses1() {

ASSERT_EQUALS("a <= 110 ;", tok("a <= (10+100);"));

ASSERT_EQUALS("while ( x ( ) == -1 ) { }", tok("while((x()) == -1){ }"));

}

void parenthesesVar() {

// remove parentheses..

ASSERT_EQUALS("a = p ;", tok("a = (p);"));

ASSERT_EQUALS("if ( a < p ) { }", tok("if(a<(p)){}"));

ASSERT_EQUALS("void f ( ) { int p ; if ( p == -1 ) { } }", tok("void f(){int p; if((p)==-1){}}"));

ASSERT_EQUALS("void f ( ) { int p ; if ( -1 == p ) { } }", tok("void f(){int p; if(-1==(p)){}}"));

ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } }", tok("void f(){int p; if((p)){}}"));

ASSERT_EQUALS("return p ;", tok("return (p);"));

ASSERT_EQUALS("void f ( ) { int * p ; if ( ! * p ) { } }", tok("void f(){int *p; if (*(p) == 0) {}}"));

ASSERT_EQUALS("void f ( ) { int * p ; if ( ! * p ) { } }", tok("void f(){int *p; if (*p == 0) {}}"));

ASSERT_EQUALS("void f ( int & p ) { p = 1 ; }", tok("void f(int &p) {(p) = 1;}"));

ASSERT_EQUALS("void f ( ) { int p [ 10 ] ; p [ 0 ] = 1 ; }", tok("void f(){int p[10]; (p)[0] = 1;}"));

ASSERT_EQUALS("void f ( ) { int p ; if ( ! p ) { } }", tok("void f(){int p; if ((p) == 0) {}}"));

ASSERT_EQUALS("void f ( ) { int * p ; * p = 1 ; }", tok("void f(){int *p; *(p) = 1;}"));

ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } p = 1 ; }", tok("void f(){int p; if ( p ) { } (p) = 1;}"));

// keep parentheses..

ASSERT_EQUALS("b = a ;", tok("b = (char)a;"));

ASSERT_EQUALS("cast < char * > ( p )", tok("cast<char *>(p)"));

ASSERT_EQUALS("return ( a + b ) * c ;", tok("return (a+b)*c;"));

ASSERT_EQUALS("void f ( ) { int p ; if ( 2 * p == 0 ) { } }", tok("void f(){int p; if (2*p == 0) {}}"));

ASSERT_EQUALS("void f ( ) { DIR * f ; f = opendir ( dirname ) ; if ( closedir ( f ) ) { } }", tok("void f(){DIR * f = opendir(dirname);if (closedir(f)){}}"));

ASSERT_EQUALS("void foo ( int p ) { if ( p >= 0 ) { ; } }", tok("void foo(int p){if((p)>=0);}"));

}

void declareVar() {

const char code[] = "void f ( ) { char str [ 100 ] = \"100\" ; }";

ASSERT_EQUALS(code, tok(code));

}

void declareArray() {

const char code1[] = "void f ( ) { char str [ ] = \"100\" ; }";

const char expected1[] = "void f ( ) { char str [ 4 ] = \"100\" ; }";

ASSERT_EQUALS(expected1, tok(code1));

const char code2[] = "char str [ ] = \"\\x00\";";

const char expected2[] = "char str [ 2 ] = \"\\0\" ;";

ASSERT_EQUALS(expected2, tok(code2));

const char code3[] = "char str [ ] = \"\\0\";";

const char expected3[] = "char str [ 2 ] = \"\\0\" ;";

ASSERT_EQUALS(expected3, tok(code3));

}

void dontRemoveIncrement() {

{

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

"{\n"

" if (a > 10)\n"

" a = 5;\n"

" else\n"

" a = 10;\n"

" a++;\n"

"}\n";

ASSERT_EQUALS("void f ( int a ) { if ( a > 10 ) { a = 5 ; } else { a = 10 ; } a ++ ; }", tok(code));

}

{

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

"{\n"

" if (a > 10)\n"

" a = 5;\n"

" else\n"

" a = 10;\n"

" ++a;\n"

"}\n";

ASSERT_EQUALS("void f ( int a ) { if ( a > 10 ) { a = 5 ; } else { a = 10 ; } ++ a ; }", tok(code));

}

}

void removePostIncrement() {

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

"{\n"

" c = 0;\n"

" c++;\n"

" if (c>0) { c++; }\n"

" c++;\n"

"}\n";

TODO_ASSERT_EQUALS("void f ( int & c ) { c = 3 ; { ; } ; }",

"void f ( int & c ) { c = 1 ; { c ++ ; } c ++ ; }", tok(code));

}

void removePreIncrement() {

{

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

"{\n"

" c = 0;\n"

" ++c;\n"

" if (c>0) { ++c; }\n"

" ++c;\n"

"}\n";

TODO_ASSERT_EQUALS("void f ( int & c ) { c = 3 ; { ; } ; }",

"void f ( int & c ) { c = 1 ; { ++ c ; } ++ c ; }", tok(code));

}

{

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

"{\n"

" char a[] = \"p\";\n"

" ++a[0];\n"

"}\n";

ASSERT_EQUALS("void f ( ) { char a [ 2 ] = \"p\" ; ++ a [ 0 ] ; }", tok(code));

}

}

std::string elseif(const char code[]) {

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.elseif();

return tokenizer.tokens()->stringifyList(false);

}

void elseif1() {

const char code[] = "else if(ab) { cd } else { ef }gh";

ASSERT_EQUALS("\n\n##file 0\n1: else { if ( ab ) { cd } else { ef } } gh\n", elseif(code));

// syntax error: assert there is no segmentation fault

ASSERT_EQUALS("\n\n##file 0\n1: else if ( x ) { }\n", elseif("else if (x) { }"));

{

const char src[] = "void f(int g,int f) {\n"

"if(g==1) {poo();}\n"

"else if( g == 2 )\n"

"{\n"

" if( f == 0 ){coo();}\n"

" else if( f==1)\n"

" goo();\n"

"}\n"

"}";

const char expected[] = "void f ( int g , int f ) "

"{ "

"if ( g == 1 ) { poo ( ) ; } "

"else { "

"if ( g == 2 ) "

"{ "

"if ( ! f ) { coo ( ) ; } "

"else { "

"if ( f == 1 ) "

"{ "

"goo ( ) ; "

"} "

"} "

"} "

"} "

"}";

ASSERT_EQUALS(tok(expected), tok(src));

}

}

void ifa_ifa() {

ASSERT_EQUALS("int a ; if ( a ) { { ab } cd }", tok("int a ; if (a) { if (a) { ab } cd }", true));

ASSERT_EQUALS("int a ; if ( a ) { { ab } cd }", tok("int a ; if (unlikely(a)) { if (a) { ab } cd }", true));

}

unsigned int sizeofFromTokenizer(const char type[]) {

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr("");

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

Token tok1(0);

tok1.str(type);

return tokenizer.sizeOfType(&tok1);

}

void sizeof_array() {

const char *code;

code = "void foo()\n"

"{\n"

" int i[4];\n"

" sizeof(i);\n"

" sizeof(*i);\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { int i [ 4 ] ; 16 ; 4 ; }", tok(code));

code = "static int i[4];\n"

"void f()\n"

"{\n"

" int i[10];\n"

" sizeof(i);\n"

"}\n";

ASSERT_EQUALS("static int i [ 4 ] ; void f ( ) { int i [ 10 ] ; 40 ; }", tok(code));

{

code = "int i[10];\n"

"sizeof(i[0]);\n";

ASSERT_EQUALS("int i [ 10 ] ; 4 ;", tok(code));

code = "int i[10];\n"

"sizeof i[0];\n";

ASSERT_EQUALS("int i [ 10 ] ; 4 ;", tok(code));

}

code = "char i[2][20];\n"

"sizeof(i[1]);";

ASSERT_EQUALS("char i [ 2 ] [ 20 ] ; 20 ;", tok(code));

}

void sizeof5() {

const char code[] =

"const char * names[2];"

"for (int i = 0; i != sizeof(names[0]); i++)"

"{}";

std::ostringstream expected;

expected << "const char * names [ 2 ] ; for ( int i = 0 ; i != " << sizeofFromTokenizer("*") << " ; i ++ ) { }";

ASSERT_EQUALS(expected.str(), tok(code));

}

void sizeof6() {

const char code[] = ";int i;\n"

"sizeof(i);\n";

std::ostringstream expected;

expected << "; int i ; " << sizeof(int) << " ;";

ASSERT_EQUALS(expected.str(), tok(code));

}

void sizeof7() {

const char code[] = ";INT32 i[10];\n"

"sizeof(i[0]);\n";

ASSERT_EQUALS("; INT32 i [ 10 ] ; sizeof ( i [ 0 ] ) ;", tok(code, true, Settings::Unspecified));

ASSERT_EQUALS("; int i [ 10 ] ; 4 ;", tokWithWindows(code, true, Settings::Win32A));

}

void sizeof8() {

{

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

"{\n"

" char* ptrs[2];\n"

" a = sizeof( ptrs );\n"

"}\n";

std::ostringstream oss;

oss << (sizeofFromTokenizer("*") * 2);

ASSERT_EQUALS("void f ( ) { char * ptrs [ 2 ] ; a = " + oss.str() + " ; }", tok(code));

}

{

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

"{\n"

" char* ptrs[55];\n"

" a = sizeof( ptrs );\n"

"}\n";

std::ostringstream oss;

oss << (sizeofFromTokenizer("*") * 55);

ASSERT_EQUALS("void f ( ) { char * ptrs [ 55 ] ; a = " + oss.str() + " ; }", tok(code));

}

{

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

"{\n"

" char* ptrs;\n"

" a = sizeof( ptrs );\n"

"}\n";

std::ostringstream oss;

oss << sizeofFromTokenizer("*");

ASSERT_EQUALS("void f ( ) { a = " + oss.str() + " ; }", tok(code));

}

}

void sizeof9() {

// ticket #487

{

const char code[] = "; const char *str = \"1\"; sizeof(str);";

std::ostringstream expected;

expected << "; const char * str ; str = \"1\" ; " << sizeofFromTokenizer("*") << " ;";

ASSERT_EQUALS(expected.str(), tok(code));

}

{

const char code[] = "; const char str[] = \"1\"; sizeof(str);";

std::ostringstream expected;

expected << "; const char str [ 2 ] = \"1\" ; " << sizeofFromTokenizer("char")*2 << " ;";

ASSERT_EQUALS(expected.str(), tok(code));

}

{

// Ticket #799

const char code[] = "; const char str[] = {'1'}; sizeof(str);";

ASSERT_EQUALS("; const char str [ 1 ] = { '1' } ; 1 ;", tok(code));

}

{

// Ticket #2087

const char code[] = "; const char str[] = {\"abc\"}; sizeof(str);";

ASSERT_EQUALS("; const char str [ 4 ] = \"abc\" ; 4 ;", tok(code));

}

// ticket #716 - sizeof string

{

std::ostringstream expected;

expected << "; " << (sizeof "123");

ASSERT_EQUALS(expected.str(), tok("; sizeof \"123\""));

ASSERT_EQUALS(expected.str(), tok("; sizeof(\"123\")"));

}

{

const char code[] = "void f(char *a,char *b, char *c)"