TestSimplifyTokens() : TestFixture("TestSimplifyTokens") {

}

void run() {

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

TEST_CASE(sizeof3);

TEST_CASE(sizeof4);

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

TEST_CASE(template2);

TEST_CASE(template3);

TEST_CASE(template4);

TEST_CASE(template5);

TEST_CASE(template6);

TEST_CASE(template7);

TEST_CASE(template8);

TEST_CASE(template9);

TEST_CASE(template10);

TEST_CASE(template11);

TEST_CASE(template12);

TEST_CASE(template13);

TEST_CASE(template14);

TEST_CASE(template15);

TEST_CASE(template16);

TEST_CASE(template17);

TEST_CASE(template18);

TEST_CASE(template19);

TEST_CASE(template20);

TEST_CASE(template21);

TEST_CASE(template22);

TEST_CASE(template23);

TEST_CASE(template24); // #2648 - using sizeof in template parameter

TEST_CASE(template25); // #2648 - another test for sizeof template parameter

TEST_CASE(template26); // #2721 - passing 'char[2]' as template parameter

TEST_CASE(template27); // #3350 - removing unused template in macro call

TEST_CASE(template28);

TEST_CASE(template29); // #3449 - don't crash for garbage code

TEST_CASE(template30); // #3529 - template < template < ..

TEST_CASE(template31); // #4010 - reference type

TEST_CASE(template32); // #3818 - mismatching template not handled well

TEST_CASE(template33); // #3818,#4544 - inner templates in template instantiation not handled well

TEST_CASE(template34); // #3706 - namespace => hang

TEST_CASE(template35); // #4074 - A<'x'> a;

TEST_CASE(template36); // #4310 - passing unknown template instantiation as template argument

TEST_CASE(template37); // #4544 - A<class B> a;

TEST_CASE(template38); // #4832 - crash on C++11 right angle brackets

TEST_CASE(template39); // #4742 - freeze

TEST_CASE(template40); // #5055 - template specialization outside struct

TEST_CASE(template41); // #4710 - const in instantiation not handled perfectly

TEST_CASE(template42); // #4878 - variadic templates

TEST_CASE(template43); // #5097 - assert due to '>>' not treated as end of template instantiation

TEST_CASE(template_unhandled);

TEST_CASE(template_default_parameter);

TEST_CASE(template_default_type);

TEST_CASE(template_typename);

TEST_CASE(template_constructor); // #3152 - template constructor is removed

// Test TemplateSimplifier::templateParameters

TEST_CASE(templateParameters);

TEST_CASE(templateParameters1); // #4169 - segmentation fault

TEST_CASE(namespaces);

// Assignment in condition..

TEST_CASE(ifassign1);

TEST_CASE(ifAssignWithCast);

TEST_CASE(whileAssign1);

TEST_CASE(whileAssign2);

TEST_CASE(whileAssign3); // varid

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

// Simplify nested strcat() calls

TEST_CASE(strcat1);

TEST_CASE(strcat2);

TEST_CASE(simplifyAtol)

TEST_CASE(simplifyTypedef1)

TEST_CASE(simplifyTypedef2)

TEST_CASE(simplifyTypedef3)

TEST_CASE(simplifyTypedef4)

TEST_CASE(simplifyTypedef5)

TEST_CASE(simplifyTypedef6)

TEST_CASE(simplifyTypedef7);

TEST_CASE(simplifyTypedef8);

TEST_CASE(simplifyTypedef9);

TEST_CASE(simplifyTypedef10);

TEST_CASE(simplifyTypedef11);

TEST_CASE(simplifyTypedef12);

TEST_CASE(simplifyTypedef13);

TEST_CASE(simplifyTypedef14);

TEST_CASE(simplifyTypedef15);

TEST_CASE(simplifyTypedef16);

TEST_CASE(simplifyTypedef17);

TEST_CASE(simplifyTypedef18); // typedef vector<int[4]> a;

TEST_CASE(simplifyTypedef19);

TEST_CASE(simplifyTypedef20);

TEST_CASE(simplifyTypedef21);

TEST_CASE(simplifyTypedef22);

TEST_CASE(simplifyTypedef23);

TEST_CASE(simplifyTypedef24);

TEST_CASE(simplifyTypedef25);

TEST_CASE(simplifyTypedef26);

TEST_CASE(simplifyTypedef27);

TEST_CASE(simplifyTypedef28);

TEST_CASE(simplifyTypedef29);

TEST_CASE(simplifyTypedef30);

TEST_CASE(simplifyTypedef31);

TEST_CASE(simplifyTypedef32);

TEST_CASE(simplifyTypedef33);

TEST_CASE(simplifyTypedef34); // ticket #1411

TEST_CASE(simplifyTypedef35);

TEST_CASE(simplifyTypedef36); // ticket #1434

TEST_CASE(simplifyTypedef37); // ticket #1449

TEST_CASE(simplifyTypedef38);

TEST_CASE(simplifyTypedef39);

TEST_CASE(simplifyTypedef40);

TEST_CASE(simplifyTypedef41); // ticket #1488

TEST_CASE(simplifyTypedef42); // ticket #1506

TEST_CASE(simplifyTypedef43); // ticket #1588

TEST_CASE(simplifyTypedef44);

TEST_CASE(simplifyTypedef45); // ticket #1613

TEST_CASE(simplifyTypedef46);

TEST_CASE(simplifyTypedef47);

TEST_CASE(simplifyTypedef48); // ticket #1673

TEST_CASE(simplifyTypedef49); // ticket #1691

TEST_CASE(simplifyTypedef50);

TEST_CASE(simplifyTypedef51);

TEST_CASE(simplifyTypedef52); // ticket #1782

TEST_CASE(simplifyTypedef53); // ticket #1801

TEST_CASE(simplifyTypedef54); // ticket #1814

TEST_CASE(simplifyTypedef55);

TEST_CASE(simplifyTypedef56); // ticket #1829

TEST_CASE(simplifyTypedef57); // ticket #1846

TEST_CASE(simplifyTypedef58); // ticket #1963

TEST_CASE(simplifyTypedef59); // ticket #2011

TEST_CASE(simplifyTypedef60); // ticket #2035

TEST_CASE(simplifyTypedef61); // ticket #2074 and 2075

TEST_CASE(simplifyTypedef62); // ticket #2082

TEST_CASE(simplifyTypedef63); // ticket #2175 'typedef float x[3];'

TEST_CASE(simplifyTypedef64);

TEST_CASE(simplifyTypedef65); // ticket #2314

TEST_CASE(simplifyTypedef66); // ticket #2341

TEST_CASE(simplifyTypedef67); // ticket #2354

TEST_CASE(simplifyTypedef68); // ticket #2355

TEST_CASE(simplifyTypedef69); // ticket #2348

TEST_CASE(simplifyTypedef70); // ticket #2348

TEST_CASE(simplifyTypedef71); // ticket #2348

TEST_CASE(simplifyTypedef72); // ticket #2375

TEST_CASE(simplifyTypedef73); // ticket #2412

TEST_CASE(simplifyTypedef74); // ticket #2414

TEST_CASE(simplifyTypedef75); // ticket #2426

TEST_CASE(simplifyTypedef76); // ticket #2453

TEST_CASE(simplifyTypedef77); // ticket #2554

TEST_CASE(simplifyTypedef78); // ticket #2568

TEST_CASE(simplifyTypedef79); // ticket #2348

TEST_CASE(simplifyTypedef80); // ticket #2587

TEST_CASE(simplifyTypedef81); // ticket #2603

TEST_CASE(simplifyTypedef82); // ticket #2403

TEST_CASE(simplifyTypedef83); // ticket #2620

TEST_CASE(simplifyTypedef84); // ticket #2630

TEST_CASE(simplifyTypedef85); // ticket #2651

TEST_CASE(simplifyTypedef86); // ticket #2581

TEST_CASE(simplifyTypedef87); // ticket #2651

TEST_CASE(simplifyTypedef88); // ticket #2675

TEST_CASE(simplifyTypedef89); // ticket #2717

TEST_CASE(simplifyTypedef90); // ticket #2718

TEST_CASE(simplifyTypedef91); // ticket #2716

TEST_CASE(simplifyTypedef92); // ticket #2736

TEST_CASE(simplifyTypedef93); // ticket #2738

TEST_CASE(simplifyTypedef94); // ticket #1982

TEST_CASE(simplifyTypedef95); // ticket #2844

TEST_CASE(simplifyTypedef96); // ticket #2886

TEST_CASE(simplifyTypedef97); // ticket #2983 (segmentation fault)

TEST_CASE(simplifyTypedef98); // ticket #2963

TEST_CASE(simplifyTypedef99); // ticket #2999

TEST_CASE(simplifyTypedef100); // ticket #3000

TEST_CASE(simplifyTypedef101); // ticket #3003 (segmentation fault)

TEST_CASE(simplifyTypedef102); // ticket #3004

TEST_CASE(simplifyTypedef103); // ticket #3007

TEST_CASE(simplifyTypedef104); // ticket #3070

TEST_CASE(simplifyTypedef105); // ticket #3616

TEST_CASE(simplifyTypedef106); // ticket #3619

TEST_CASE(simplifyTypedef107); // ticket #3963 - bad code => segmentation fault

TEST_CASE(simplifyTypedefFunction1);

TEST_CASE(simplifyTypedefFunction2); // ticket #1685

TEST_CASE(simplifyTypedefFunction3);

TEST_CASE(simplifyTypedefFunction4);

TEST_CASE(simplifyTypedefFunction5);

TEST_CASE(simplifyTypedefFunction6);

TEST_CASE(simplifyTypedefFunction7);

TEST_CASE(simplifyTypedefFunction8);

TEST_CASE(simplifyTypedefShadow); // #4445 - shadow variable

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(enumscope1); // ticket #3949

TEST_CASE(duplicateDefinition); // ticket #3565

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

TEST_CASE(simplifyFlowControl);

}

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 tok(const std::string& code, bool simplify = true, Settings::PlatformType type = Settings::Unspecified) {

return tok(code.c_str(), simplify, type);

}

std::string tok(const char code[], const char filename[]) {

errout.str("");

Settings settings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

tokenizer.simplifyTokenList2();

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

}

std::string tokenizeDebugListing(const std::string &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("<= 110 ;", tok("<= (10+100);"));

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

}

void parenthesesVar() {

// remove parentheses..

ASSERT_EQUALS("= p ;", tok("= (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("= a ;", tok("= (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);