TestSimplifyTokens() : TestFixture("TestSimplifyTokens") {}

Settings settings0;

Settings settings1;

Settings settings_std;

Settings settings_windows;

void run() override {

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

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

settings0.severity.enable(Severity::portability);

settings1.severity.enable(Severity::style);

settings_windows.severity.enable(Severity::portability);

// If there are unused templates, keep those

settings0.checkUnusedTemplates = true;

settings1.checkUnusedTemplates = true;

settings_std.checkUnusedTemplates = true;

settings_windows.checkUnusedTemplates = true;

TEST_CASE(combine_strings);

TEST_CASE(combine_wstrings);

TEST_CASE(combine_ustrings);

TEST_CASE(combine_Ustrings);

TEST_CASE(combine_u8strings);

TEST_CASE(combine_mixedstrings);

TEST_CASE(double_plus);

TEST_CASE(redundant_plus);

TEST_CASE(redundant_plus_numbers);

TEST_CASE(declareVar);

TEST_CASE(declareArray);

TEST_CASE(dontRemoveIncrement);

TEST_CASE(elseif1);

TEST_CASE(namespaces);

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

TEST_CASE(simplifyOperator2);

TEST_CASE(simplifyArrayAccessSyntax);

TEST_CASE(pointeralias1);

TEST_CASE(pointeralias3);

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

TEST_CASE(simplifyStructDecl1);

TEST_CASE(simplifyStructDecl2); // ticket #2579

TEST_CASE(simplifyStructDecl3);

TEST_CASE(simplifyStructDecl4);

TEST_CASE(simplifyStructDecl6); // ticket #3732

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

TEST_CASE(simplifyStructDecl8); // ticket #7698

// register int var; => int var;

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

TEST_CASE(removeUnwantedKeywords);

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

TEST_CASE(simplifyCallingConvention);

// remove __attribute, __attribute__

TEST_CASE(simplifyAttribute);

TEST_CASE(simplifyFunctorCall);

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

TEST_CASE(simplifyFunctionReturn);

TEST_CASE(consecutiveBraces);

TEST_CASE(simplifyOverride); // ticket #5069

TEST_CASE(simplifyNestedNamespace);

TEST_CASE(simplifyNamespaceAliases1);

TEST_CASE(simplifyNamespaceAliases2); // ticket #10281

TEST_CASE(simplifyKnownVariables2);

TEST_CASE(simplifyKnownVariables3);

TEST_CASE(simplifyKnownVariables4);

TEST_CASE(simplifyKnownVariables5);

TEST_CASE(simplifyKnownVariables13);

TEST_CASE(simplifyKnownVariables14);

TEST_CASE(simplifyKnownVariables16);

TEST_CASE(simplifyKnownVariables17);

TEST_CASE(simplifyKnownVariables18);

TEST_CASE(simplifyKnownVariables19);

TEST_CASE(simplifyKnownVariables21);

TEST_CASE(simplifyKnownVariables25);

// FIXME Does expression id handle these? TEST_CASE(simplifyKnownVariables29); // ticket #1811

TEST_CASE(simplifyKnownVariables30);

TEST_CASE(simplifyKnownVariables34);

TEST_CASE(simplifyKnownVariables36); // ticket #5972

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(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(simplifyKnownVariables54); // #4913 'x' is not 0 after *--x=0;

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

TEST_CASE(simplifyKnownVariables58); // ticket #5268

TEST_CASE(simplifyKnownVariables59); // skip for header

TEST_CASE(simplifyKnownVariables61); // #7805

TEST_CASE(simplifyKnownVariables62); // #5666 - p=&str[0]

TEST_CASE(simplifyKnownVariables63); // #10798

TEST_CASE(simplifyKnownVariablesBailOutAssign1);

TEST_CASE(simplifyKnownVariablesBailOutAssign2);

TEST_CASE(simplifyKnownVariablesBailOutFor1);

TEST_CASE(simplifyKnownVariablesBailOutFor2);

TEST_CASE(simplifyKnownVariablesBailOutFor3);

TEST_CASE(simplifyKnownVariablesBailOutMemberFunction);

TEST_CASE(simplifyKnownVariablesBailOutConditionalIncrement);

TEST_CASE(simplifyKnownVariablesBailOutSwitchBreak); // ticket #2324

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

TEST_CASE(simplifyKnownVariablesNamespace); // #10059

TEST_CASE(simplify_constants6); // Ticket #5625: Ternary operator as template parameter

TEST_CASE(simplifyVarDeclInitLists);

}

#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)

std::string tok_(const char* file, int line, const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native) {

errout.str("");

settings0.platform(type);

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, "test.cpp"), file, line);

(void)simplify;

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

}

std::string tok_(const char* file, int line, const char code[], const char filename[], bool simplify = true) {

errout.str("");

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, filename), file, line);

(void)simplify;

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

}

#define tokenizeAndStringify(...) tokenizeAndStringify_(__FILE__, __LINE__, __VA_ARGS__)

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

errout.str("");

settings1.debugwarnings = true;

settings1.platform(platform);

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

// tokenize..

Tokenizer tokenizer(&settings1, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, filename), file, linenr);

(void)simplify;

// filter out ValueFlow messages..

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

errout.str("");

std::istringstream istr2(debugwarnings);

std::string line;

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

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

errout << line << "\n";

}

if (tokenizer.tokens())

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

else

return "";

}

#define tokenizeDebugListing(...) tokenizeDebugListing_(__FILE__, __LINE__, __VA_ARGS__)

std::string tokenizeDebugListing_(const char* file, int line, const char code[], bool simplify = false, const char filename[] = "test.cpp") {

errout.str("");

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, filename), file, line);

(void)simplify;

// result..

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

}

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

const char code3[] = "x = L\"1\" TEXT(\"2\") L\"3\";";

ASSERT_EQUALS("x = L\"123\" ;", tok(code3, false, Settings::Win64));

const char code4[] = "x = TEXT(\"1\") L\"2\";";

ASSERT_EQUALS("x = L\"1\" L\"2\" ;", tok(code4, false, Settings::Win64));

}

void combine_wstrings() {

const char code[] = "a = L\"hello \" L\"world\" ;\n";

const char expected[] = "a = L\"hello world\" ;";

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));

}

void combine_ustrings() {

const char code[] = "abcd = u\"ab\" u\"cd\";";

const char expected[] = "abcd = u\"abcd\" ;";

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));

}

void combine_Ustrings() {

const char code[] = "abcd = U\"ab\" U\"cd\";";

const char expected[] = "abcd = U\"abcd\" ;";

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));

}

void combine_u8strings() {

const char code[] = "abcd = u8\"ab\" u8\"cd\";";

const char expected[] = "abcd = u8\"abcd\" ;";

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));

}

void combine_mixedstrings() {

const char code[] = "abcdef = \"ab\" L\"cd\" \"ef\";";

const char expected[] = "abcdef = L\"abcdef\" ;";

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));

}

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

const char code4[] = "char str [ ] = \"\\n\\n\";";

const char expected4[] = "char str [ 3 ] = \"\\n\\n\" ;";

ASSERT_EQUALS(expected4, tok(code4));

}

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

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

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

// syntax error: assert there is no segmentation fault

ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( x ) { } } }\n", tokenizeDebugListing("void f(){ if(x) {} 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 == 0 ) { coo ( ) ; } "

"else { "

"if ( f == 1 ) "

"{ "

"goo ( ) ; "

"} "

"} "

"} "

"} "

"}";

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

}

// Ticket #6860 - lambdas

{

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

const char expected[] = "\n\n##file 0\n1: ( [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) ) ;\n";

ASSERT_EQUALS(expected, tokenizeDebugListing(src));

}

{

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

const char expected[] = "\n\n##file 0\n1: [ [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) ] ;\n";

ASSERT_EQUALS(expected, tokenizeDebugListing(src));

}

{

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

const char expected[] = "\n\n##file 0\n1: = { [ ] { if ( ab ) { cd } else { if ( ef ) { gh } else { ij } } kl } ( ) }\n";

ASSERT_EQUALS(expected, tokenizeDebugListing(src));

}

}

void namespaces() {

{

const char code[] = "namespace std { }";

ASSERT_EQUALS(";", tok(code));

}

{

const char code[] = "; namespace std { }";

ASSERT_EQUALS(";", tok(code));

}

{

const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }";

const char expected[] = "namespace a { namespace b { void f ( ) { } } }";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "namespace b{ void f(){} }";

const char expected[] = "namespace b { void f ( ) { } }";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "void f(int namespace) { }";

const char expected[] = "void f ( int namespace ) { }";

ASSERT_EQUALS(expected, tok(code));

}

}

void not1() {

ASSERT_EQUALS("void f ( ) { if ( ! p ) { ; } }", tok("void f() { if (not p); }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }", tok("void f() { if (p && not q); }", "test.c"));

ASSERT_EQUALS("void f ( ) { a = ! ( p && q ) ; }", tok("void f() { a = not(p && q); }", "test.c"));

// Don't simplify 'not' or 'compl' if they are defined as a type;

// in variable declaration and in function declaration/definition

ASSERT_EQUALS("struct not { int x ; } ;", tok("struct not { int x; };", "test.c"));

ASSERT_EQUALS("void f ( ) { not p ; compl c ; }", tok(" void f() { not p; compl c; }", "test.c"));

ASSERT_EQUALS("void foo ( not i ) ;", tok("void foo(not i);", "test.c"));

ASSERT_EQUALS("int foo ( not i ) { return g ( i ) ; }", tok("int foo(not i) { return g(i); }", "test.c"));

}

void and1() {

ASSERT_EQUALS("void f ( ) { if ( p && q ) { ; } }",

tok("void f() { if (p and q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( foo ( ) && q ) { ; } }",

tok("void f() { if (foo() and q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( foo ( ) && bar ( ) ) { ; } }",

tok("void f() { if (foo() and bar()) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( p && bar ( ) ) { ; } }",

tok("void f() { if (p and bar()) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }",

tok("void f() { if (p and not q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { r = a && b ; }",

tok("void f() { r = a and b; }", "test.c"));

ASSERT_EQUALS("void f ( ) { r = ( a || b ) && ( c || d ) ; }",

tok("void f() { r = (a || b) and (c || d); }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( test1 [ i ] == 'A' && test2 [ i ] == 'C' ) { } }",

tok("void f() { if (test1[i] == 'A' and test2[i] == 'C') {} }", "test.c"));

}

void or1() {

ASSERT_EQUALS("void f ( ) { if ( p || q ) { ; } }",

tok("void f() { if (p or q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( foo ( ) || q ) { ; } }",

tok("void f() { if (foo() or q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( foo ( ) || bar ( ) ) { ; } }",

tok("void f() { if (foo() or bar()) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( p || bar ( ) ) { ; } }",

tok("void f() { if (p or bar()) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { if ( p || ! q ) { ; } }",

tok("void f() { if (p or not q) ; }", "test.c"));

ASSERT_EQUALS("void f ( ) { r = a || b ; }",

tok("void f() { r = a or b; }", "test.c"));

ASSERT_EQUALS("void f ( ) { r = ( a && b ) || ( c && d ) ; }",

tok("void f() { r = (a && b) or (c && d); }", "test.c"));

}

void cAlternativeTokens() {

ASSERT_EQUALS("void f ( ) { err |= ( ( r & s ) && ! t ) ; }",

tok("void f() { err or_eq ((r bitand s) and not t); }", "test.c"));

ASSERT_EQUALS("void f ( ) const { r = f ( a [ 4 ] | 0x0F , ~ c , ! d ) ; }",

tok("void f() const { r = f(a[4] bitor 0x0F, compl c, not d) ; }", "test.c"));

}

void comma_keyword() {

{

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

"{\n"

" char *a, *b;\n"

" delete a, delete b;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a , delete b ; }", tok(code));

}

{

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

"{\n"

" struct A *a, *b;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { struct A * a ; struct A * b ; }", tok(code));

}

{

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

"{\n"

" struct A **a, **b;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { struct A * * a ; struct A * * b ; }", tok(code));

}

{

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

"{\n"

" char *a, *b;\n"

" delete a, b;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a , b ; }", tok(code));

}

{

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

"{\n"

" char *a, *b, *c;\n"

" delete a, b, c;\n"

"}\n";

// delete a; b; c; would be better but this will do too

ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; delete a , b , c ; }", tok(code));

}

{

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

"{\n"

" char *a, *b;\n"

" if (x)\n"

" delete a, b;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; if ( x ) { delete a , b ; } }", tok(code));

}

{

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

"{\n"

" char *a, *b, *c;\n"

" if (x) \n"

" delete a, b, c;\n"

"}\n";

// delete a; b; c; would be better but this will do too

ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; if ( x ) { delete a , b , c ; } }", tok(code));

}

{

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

"{\n"

" char **a, **b, **c;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { char * * a ; char * * b ; char * * c ; }", tok(code));

}

{

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

"{\n"

" delete [] a, a = 0;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { delete [ ] a , a = 0 ; }", tok(code));

}

{

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

"{\n"

" delete a, a = 0;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { delete a , a = 0 ; }", tok(code));

}

{

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

"{\n"

" if( x ) delete a, a = 0;\n"

"}\n";

ASSERT_EQUALS("void foo ( ) { if ( x ) { delete a , a = 0 ; } }", tok(code));

}

{

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

"{\n"

" for(int a,b; a < 10; a = a + 1, b = b + 1);\n"

"}\n";

ASSERT_EQUALS("void f ( ) { for ( int a , b ; a < 10 ; a = a + 1 , b = b + 1 ) { ; } }", tok(code));

}

{

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

"{\n"

" char buf[BUFSIZ], **p;\n"

" char *ptrs[BUFSIZ], **pp;\n"

"}\n";

ASSERT_EQUALS("void f ( ) { char buf [ BUFSIZ ] ; char * * p ; char * ptrs [ BUFSIZ ] ; char * * pp ; }", tok(code));

}

{

// #4786 - don't replace , with ; in ".. : public B, C .." code

const char code[] = "template < class T = X > class A : public B , C { } ;";

ASSERT_EQUALS(code, tok(code));

}

}

void simplifyOperator1() {

// #3237 - error merging namespaces with operators

const char code[] = "class c {\n"

"public:\n"

" operator std::string() const;\n"

" operator string() const;\n"

"};\n";

const char expected[] = "class c { "

"public: "

"operatorstd::string ( ) const ; "

"operatorstring ( ) const ; "

"} ;";

ASSERT_EQUALS(expected, tok(code));

}

void simplifyOperator2() {

// #6576

ASSERT_EQUALS("template < class T > class SharedPtr { "

"SharedPtr & operator= ( const SharedPtr < Y > & r ) ; "

"} ; "

"class TClass { "

"public: TClass & operator= ( const TClass & rhs ) ; "

"} ; "

"TClass :: TClass ( const TClass & other ) { operator= ( other ) ; }",

tok("template<class T>\n"

" class SharedPtr {\n"

" SharedPtr& operator=(SharedPtr<Y> const & r);\n"

"};\n"

"class TClass {\n"

"public:\n"

" TClass& operator=(const TClass& rhs);\n"

"};\n"

"TClass::TClass(const TClass &other) {\n"

" operator=(other);\n"

"}"));

}

void simplifyArrayAccessSyntax() {

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

"1: int a@1 ; a@1 [ 13 ] ;\n", tokenizeDebugListing("int a; 13[a];"));

}

void pointeralias1() {

{

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

"{\n"

" char *p = p1;\n"

" p1 = 0;"

" x(p);\n"

"}\n";

const char expected[] = "void f ( char * p1 ) "

"{ "

"char * p ; p = p1 ; "

"p1 = 0 ; "

"x ( p ) ; "

"}";

ASSERT_EQUALS(expected, tok(code));

}

{

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

"{\n"

" Result* obj = ptr;\n"

" ++obj->total;\n"

"}\n";

const char expected[] = "void foo ( Result * ptr ) "

"{ "

"Result * obj ; obj = ptr ; "

"++ obj . total ; "

"}";

ASSERT_EQUALS(expected, tok(code));

}

}

void pointeralias3() {

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

"{\n"

" int i, j, *p;\n"

" if (ab) p = &i;\n"

" else p = &j;\n"

" *p = 0;\n"

"}\n";

const char expected[] = "void f ( ) "

"{"

" int i ; int j ; int * p ;"

" if ( ab ) { p = & i ; }"

" else { p = & j ; }"

" * p = 0 ; "

"}";

ASSERT_EQUALS(expected, tok(code));

}

void simplifyStructDecl1() {

{

const char code[] = "struct ABC { } abc;";

const char expected[] = "struct ABC { } ; struct ABC abc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct ABC { } * pabc;";

const char expected[] = "struct ABC { } ; struct ABC * pabc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct ABC { } abc[4];";

const char expected[] = "struct ABC { } ; struct ABC abc [ 4 ] ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct ABC { } abc, def;";

const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC def ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct ABC { } abc, * pabc;";

const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC * pabc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct ABC { struct DEF {} def; } abc;";

const char expected[] = "struct ABC { struct DEF { } ; struct DEF def ; } ; struct ABC abc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct { } abc;";

const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct { } * pabc;";

const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 * pabc ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct { } abc[4];";

const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc [ 4 ] ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "struct {int a;} const array[3] = {0};";

const char expected[] = "struct Anonymous0 { int a ; } ; struct Anonymous0 const array [ 3 ] = { 0 } ;";

ASSERT_EQUALS(expected, tok(code));

}

{

const char code[] = "static struct {int a;} const array[3] = {0};";

const char expected[] = "struct Anonymous0 { int a ; } ; static struct Anonymous0 const array [ 3 ] = { 0 } ;";