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;

// 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(test1); // array access. replace "*(p+1)" => "p[1]"

TEST_CASE(simplifyMathFunctions_sqrt);

TEST_CASE(simplifyMathFunctions_cbrt);

TEST_CASE(simplifyMathFunctions_exp);

TEST_CASE(simplifyMathFunctions_exp2);

TEST_CASE(simplifyMathFunctions_logb);

TEST_CASE(simplifyMathFunctions_log1p);

TEST_CASE(simplifyMathFunctions_ilogb);

TEST_CASE(simplifyMathFunctions_log10);

TEST_CASE(simplifyMathFunctions_log);

TEST_CASE(simplifyMathFunctions_log2);

TEST_CASE(simplifyMathFunctions_pow);

TEST_CASE(simplifyMathFunctions_fmin);

TEST_CASE(simplifyMathFunctions_fmax);

TEST_CASE(simplifyMathFunctions_acosh);

TEST_CASE(simplifyMathFunctions_acos);

TEST_CASE(simplifyMathFunctions_cosh);

TEST_CASE(simplifyMathFunctions_cos);

TEST_CASE(simplifyMathFunctions_erfc);

TEST_CASE(simplifyMathFunctions_erf);

TEST_CASE(simplifyMathFunctions_sin);

TEST_CASE(simplifyMathFunctions_sinh);

TEST_CASE(simplifyMathFunctions_asin);

TEST_CASE(simplifyMathFunctions_asinh);

TEST_CASE(simplifyMathFunctions_tan);

TEST_CASE(simplifyMathFunctions_tanh);

TEST_CASE(simplifyMathFunctions_atan);

TEST_CASE(simplifyMathFunctions_atanh);

TEST_CASE(simplifyMathFunctions_expm1);

TEST_CASE(simplifyMathExpressions); //ticket #1620

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

TEST_CASE(simplifyAssignmentInFunctionCall);

// ";a+=b;" => ";a=a+b;"

TEST_CASE(simplifyCompoundAssignment);

TEST_CASE(cast);

TEST_CASE(iftruefalse);

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

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

TEST_CASE(declareVar);

TEST_CASE(declareArray);

TEST_CASE(dontRemoveIncrement);

TEST_CASE(removePostIncrement);

TEST_CASE(removePreIncrement);

TEST_CASE(elseif1);

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

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

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

TEST_CASE(simplifyCalculations);

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

TEST_CASE(simplifyArrayAccessSyntax);

TEST_CASE(simplify_numeric_condition);

TEST_CASE(simplify_condition);

TEST_CASE(pointeralias1);

TEST_CASE(pointeralias2);

TEST_CASE(pointeralias3);

TEST_CASE(pointeralias4);

// simplify "while (0)"

TEST_CASE(while0);

// ticket #3140

TEST_CASE(while0for);

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

TEST_CASE(simplifyFunctorCall);

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

TEST_CASE(redundant_semicolon);

TEST_CASE(simplifyFunctionReturn);

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

TEST_CASE(simplifyNamespaceAliases);

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

TEST_CASE(simplifyKnownVariables27);

TEST_CASE(simplifyKnownVariables28);

TEST_CASE(simplifyKnownVariables29); // ticket #1811

TEST_CASE(simplifyKnownVariables30);

TEST_CASE(simplifyKnownVariables31);

TEST_CASE(simplifyKnownVariables32); // const

TEST_CASE(simplifyKnownVariables33); // struct variable

TEST_CASE(simplifyKnownVariables34);

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

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

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

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

TEST_CASE(simplifyKnownVariables39);

TEST_CASE(simplifyKnownVariables40);

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

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

TEST_CASE(simplifyKnownVariables43);

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

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

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

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

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

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

TEST_CASE(simplifyKnownVariables50); // #4066 sprintf changes

TEST_CASE(simplifyKnownVariables51); // #4409 hang

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

TEST_CASE(simplifyKnownVariables53); // references

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

TEST_CASE(simplifyKnownVariables55); // pointer alias

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

TEST_CASE(simplifyKnownVariables57); // ticket #4724

TEST_CASE(simplifyKnownVariables58); // ticket #5268

TEST_CASE(simplifyKnownVariables59); // skip for header

TEST_CASE(simplifyKnownVariables60); // #6829

TEST_CASE(simplifyKnownVariables61); // #7805

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

TEST_CASE(simplifyKnownVariablesBailOutAssign1);

TEST_CASE(simplifyKnownVariablesBailOutAssign2);

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

TEST_CASE(simplifyKnownVariablesBailOutFor1);

TEST_CASE(simplifyKnownVariablesBailOutFor2);

TEST_CASE(simplifyKnownVariablesBailOutFor3);

TEST_CASE(simplifyKnownVariablesBailOutMemberFunction);

TEST_CASE(simplifyKnownVariablesBailOutConditionalIncrement);

TEST_CASE(simplifyKnownVariablesBailOutSwitchBreak); // ticket #2324

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

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

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

TEST_CASE(simplifyKnownVariablesGlobalVars);

TEST_CASE(simplifyKnownVariablesReturn); // 3500 - return

TEST_CASE(simplifyKnownVariablesPointerAliasFunctionCall); // #7440

TEST_CASE(simplifyCasts1);

TEST_CASE(simplifyCasts2);

TEST_CASE(simplifyCasts3);

TEST_CASE(simplifyCasts4);

TEST_CASE(simplifyCasts5);

TEST_CASE(simplifyCasts7);

TEST_CASE(simplifyCasts8);

TEST_CASE(simplifyCasts9);

TEST_CASE(simplifyCasts10);

TEST_CASE(simplifyCasts11);

TEST_CASE(simplifyCasts12);

TEST_CASE(simplifyCasts13);

TEST_CASE(simplifyCasts14);

TEST_CASE(simplifyCasts15); // #5996 - don't remove cast in 'a+static_cast<int>(b?60:0)'

TEST_CASE(simplifyCasts16); // #6278

TEST_CASE(simplifyCasts17); // #6110 - don't remove any parentheses in 'a(b)(c)'

TEST_CASE(removeRedundantAssignment);

TEST_CASE(simplify_constants);

TEST_CASE(simplify_constants2);

TEST_CASE(simplify_constants3);

TEST_CASE(simplify_constants4);

TEST_CASE(simplify_constants5);

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

}

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

errout.str("");

settings0.platform(type);

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

if (simplify)

tokenizer.simplifyTokenList2();

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

}

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

errout.str("");

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(nullptr, !simplify);

}

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

errout.str("");

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

if (simplify)

tokenizer.simplifyTokenList2();

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

}

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

errout.str("");

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList2();

return tokenizer.tokens()->stringifyList(false, false, false, true, 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(nullptr, false);

}

std::string tokenizeAndStringify(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);

tokenizer.tokenize(istr, filename);

if (simplify)

tokenizer.simplifyTokenList2();

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

}

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

errout.str("");

Tokenizer tokenizer(&settings0, 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 test1() {

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

/*

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

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

ASSERT_EQUALS("; x = p [ 0xA ] ;", tok("; x = * ( p + 0xA ) ;"));

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

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

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

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

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

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

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

ASSERT_EQUALS("; x = p [ -0xA ] ;", tok("; x = *(p - 0xA);"));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

void simplifyMathFunctions_erfc() {

// verify erfc(), erfcf(), erfcl() - simplifcation

const char code_erfc[] ="void f(int x) {\n"

" std::cout << erfc(x);\n" // do not simplify

" std::cout << erfc(0L);\n" // simplify to 1

"}";

const char expected_erfc[] = "void f ( int x ) {\n"

"std :: cout << erfc ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_erfc, tokWithNewlines(code_erfc));

const char code_erfcf[] ="void f(float x) {\n"

" std::cout << erfcf(x);\n" // do not simplify

" std::cout << erfcf(0.0f);\n" // simplify to 1

"}";

const char expected_erfcf[] = "void f ( float x ) {\n"

"std :: cout << erfcf ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_erfcf, tokWithNewlines(code_erfcf));

const char code_erfcl[] ="void f(long double x) {\n"

" std::cout << erfcl(x);\n" // do not simplify

" std::cout << erfcl(0.0f);\n" // simplify to 1

"}";

const char expected_erfcl[] = "void f ( double x ) {\n"

"std :: cout << erfcl ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_erfcl, tokWithNewlines(code_erfcl));

}

void simplifyMathFunctions_cos() {

// verify cos(), cosf(), cosl() - simplifcation

const char code_cos[] ="void f(int x) {\n"

" std::cout << cos(x);\n" // do not simplify

" std::cout << cos(0L);\n" // simplify to 1

"}";

const char expected_cos[] = "void f ( int x ) {\n"

"std :: cout << cos ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cos, tokWithNewlines(code_cos));

const char code_cosf[] ="void f(float x) {\n"

" std::cout << cosf(x);\n" // do not simplify

" std::cout << cosf(0.0f);\n" // simplify to 1

"}";

const char expected_cosf[] = "void f ( float x ) {\n"

"std :: cout << cosf ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cosf, tokWithNewlines(code_cosf));

const char code_cosl[] ="void f(long double x) {\n"

" std::cout << cosl(x);\n" // do not simplify

" std::cout << cosl(0.0f);\n" // simplify to 1

"}";

const char expected_cosl[] = "void f ( double x ) {\n"

"std :: cout << cosl ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cosl, tokWithNewlines(code_cosl));

}

void simplifyMathFunctions_cosh() {

// verify cosh(), coshf(), coshl() - simplifcation

const char code_cosh[] ="void f(int x) {\n"

" std::cout << cosh(x);\n" // do not simplify

" std::cout << cosh(0L);\n" // simplify to 1

"}";

const char expected_cosh[] = "void f ( int x ) {\n"

"std :: cout << cosh ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cosh, tokWithNewlines(code_cosh));

const char code_coshf[] ="void f(float x) {\n"

" std::cout << coshf(x);\n" // do not simplify

" std::cout << coshf(0.0f);\n" // simplify to 1

"}";

const char expected_coshf[] = "void f ( float x ) {\n"

"std :: cout << coshf ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_coshf, tokWithNewlines(code_coshf));

const char code_coshl[] ="void f(long double x) {\n"

" std::cout << coshl(x);\n" // do not simplify

" std::cout << coshl(0.0f);\n" // simplify to 1

"}";

const char expected_coshl[] = "void f ( double x ) {\n"

"std :: cout << coshl ( x ) ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_coshl, tokWithNewlines(code_coshl));

}

void simplifyMathFunctions_acos() {

// verify acos(), acosf(), acosl() - simplifcation

const char code_acos[] ="void f(int x) {\n"

" std::cout << acos(x);\n" // do not simplify

" std::cout << acos(1L);\n" // simplify to 0

"}";

const char expected_acos[] = "void f ( int x ) {\n"

"std :: cout << acos ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acos, tokWithNewlines(code_acos));

const char code_acosf[] ="void f(float x) {\n"

" std::cout << acosf(x);\n" // do not simplify

" std::cout << acosf(1.0f);\n" // simplify to 0

"}";

const char expected_acosf[] = "void f ( float x ) {\n"

"std :: cout << acosf ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acosf, tokWithNewlines(code_acosf));

const char code_acosl[] ="void f(long double x) {\n"

" std::cout << acosl(x);\n" // do not simplify

" std::cout << acosl(1.0f);\n" // simplify to 0

"}";

const char expected_acosl[] = "void f ( double x ) {\n"

"std :: cout << acosl ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acosl, tokWithNewlines(code_acosl));

}

void simplifyMathFunctions_acosh() {

// verify acosh(), acoshf(), acoshl() - simplifcation

const char code_acosh[] ="void f(int x) {\n"

" std::cout << acosh(x);\n" // do not simplify

" std::cout << acosh(1L);\n" // simplify to 0

"}";

const char expected_acosh[] = "void f ( int x ) {\n"

"std :: cout << acosh ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acosh, tokWithNewlines(code_acosh));

const char code_acoshf[] ="void f(float x) {\n"

" std::cout << acoshf(x);\n" // do not simplify

" std::cout << acoshf(1.0f);\n" // simplify to 0

"}";

const char expected_acoshf[] = "void f ( float x ) {\n"

"std :: cout << acoshf ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acoshf, tokWithNewlines(code_acoshf));

const char code_acoshl[] ="void f(long double x) {\n"

" std::cout << acoshl(x);\n" // do not simplify

" std::cout << acoshl(1.0f);\n" // simplify to 0

"}";

const char expected_acoshl[] = "void f ( double x ) {\n"

"std :: cout << acoshl ( x ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_acoshl, tokWithNewlines(code_acoshl));

}

void simplifyMathFunctions_sqrt() {

// verify sqrt(), sqrtf(), sqrtl() - simplifcation

const char code_sqrt[] ="void f(int x) {\n"

" std::cout << sqrt(x);\n" // do not simplify

" std::cout << sqrt(-1);\n" // do not simplify

" std::cout << sqrt(0L);\n" // simplify to 0

" std::cout << sqrt(1L);\n" // simplify to 1

"}";

const char expected_sqrt[] = "void f ( int x ) {\n"

"std :: cout << sqrt ( x ) ;\n"

"std :: cout << sqrt ( -1 ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_sqrt, tokWithNewlines(code_sqrt));

const char code_sqrtf[] ="void f(float x) {\n"

" std::cout << sqrtf(x);\n" // do not simplify

" std::cout << sqrtf(-1.0f);\n" // do not simplify

" std::cout << sqrtf(0.0f);\n" // simplify to 0

" std::cout << sqrtf(1.0);\n" // simplify to 1

"}";

const char expected_sqrtf[] = "void f ( float x ) {\n"

"std :: cout << sqrtf ( x ) ;\n"

"std :: cout << sqrtf ( -1.0f ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_sqrtf, tokWithNewlines(code_sqrtf));

const char code_sqrtl[] ="void f(long double x) {\n"

" std::cout << sqrtf(x);\n" // do not simplify

" std::cout << sqrtf(-1.0);\n" // do not simplify

" std::cout << sqrtf(0.0);\n" // simplify to 0

" std::cout << sqrtf(1.0);\n" // simplify to 1

"}";

const char expected_sqrtl[] = "void f ( double x ) {\n"

"std :: cout << sqrtf ( x ) ;\n"

"std :: cout << sqrtf ( -1.0 ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_sqrtl, tokWithNewlines(code_sqrtl));

}

void simplifyMathFunctions_cbrt() {

// verify cbrt(), cbrtf(), cbrtl() - simplifcation

const char code_cbrt[] ="void f(int x) {\n"

" std::cout << cbrt(x);\n" // do not simplify

" std::cout << cbrt(-1);\n" // do not simplify

" std::cout << cbrt(0L);\n" // simplify to 0

" std::cout << cbrt(1L);\n" // simplify to 1

"}";

const char expected_cbrt[] = "void f ( int x ) {\n"

"std :: cout << cbrt ( x ) ;\n"

"std :: cout << cbrt ( -1 ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cbrt, tokWithNewlines(code_cbrt));

const char code_cbrtf[] ="void f(float x) {\n"

" std::cout << cbrtf(x);\n" // do not simplify

" std::cout << cbrtf(-1.0f);\n" // do not simplify

" std::cout << cbrtf(0.0f);\n" // simplify to 0

" std::cout << cbrtf(1.0);\n" // simplify to 1

"}";

const char expected_cbrtf[] = "void f ( float x ) {\n"

"std :: cout << cbrtf ( x ) ;\n"

"std :: cout << cbrtf ( -1.0f ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cbrtf, tokWithNewlines(code_cbrtf));

const char code_cbrtl[] ="void f(long double x) {\n"

" std::cout << cbrtl(x);\n" // do not simplify

" std::cout << cbrtl(-1.0);\n" // do not simplify

" std::cout << cbrtl(0.0);\n" // simplify to 0

" std::cout << cbrtl(1.0);\n" // simplify to 1

"}";

const char expected_cbrtl[] = "void f ( double x ) {\n"

"std :: cout << cbrtl ( x ) ;\n"

"std :: cout << cbrtl ( -1.0 ) ;\n"

"std :: cout << 0 ;\n"

"std :: cout << 1 ;\n"

"}";

ASSERT_EQUALS(expected_cbrtl, tokWithNewlines(code_cbrtl));

}

void simplifyMathFunctions_exp2() {

// verify exp2(), exp2f(), exp2l() - simplifcation

const char code_exp2[] ="void f(int x) {\n"

" std::cout << exp2(x);\n" // do not simplify

" std::cout << exp2(-1);\n" // do not simplify

" std::cout << exp2(0L);\n" // simplify to 0

" std::cout << exp2(1L);\n" // do not simplify

"}";

const char expected_exp2[] = "void f ( int x ) {\n"

"std :: cout << exp2 ( x ) ;\n"

"std :: cout << exp2 ( -1 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << exp2 ( 1L ) ;\n"

"}";

ASSERT_EQUALS(expected_exp2, tokWithNewlines(code_exp2));

const char code_exp2f[] ="void f(float x) {\n"

" std::cout << exp2f(x);\n" // do not simplify

" std::cout << exp2f(-1.0);\n" // do not simplify

" std::cout << exp2f(0.0);\n" // simplify to 1

" std::cout << exp2f(1.0);\n" // do not simplify

"}";

const char expected_exp2f[] = "void f ( float x ) {\n"

"std :: cout << exp2f ( x ) ;\n"

"std :: cout << exp2f ( -1.0 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << exp2f ( 1.0 ) ;\n"

"}";

ASSERT_EQUALS(expected_exp2f, tokWithNewlines(code_exp2f));

const char code_exp2l[] ="void f(long double x) {\n"

" std::cout << exp2l(x);\n" // do not simplify

" std::cout << exp2l(-1.0);\n" // do not simplify

" std::cout << exp2l(0.0);\n" // simplify to 1

" std::cout << exp2l(1.0);\n" // do not simplify

"}";

const char expected_exp2l[] = "void f ( double x ) {\n"

"std :: cout << exp2l ( x ) ;\n"

"std :: cout << exp2l ( -1.0 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << exp2l ( 1.0 ) ;\n"

"}";

ASSERT_EQUALS(expected_exp2l, tokWithNewlines(code_exp2l));

}

void simplifyMathFunctions_exp() {

// verify exp(), expf(), expl() - simplifcation

const char code_exp[] ="void f(int x) {\n"

" std::cout << exp(x);\n" // do not simplify

" std::cout << exp(-1);\n" // do not simplify

" std::cout << exp(0L);\n" // simplify to 1

" std::cout << exp(1L);\n" // do not simplify

"}";

const char expected_exp[] = "void f ( int x ) {\n"

"std :: cout << exp ( x ) ;\n"

"std :: cout << exp ( -1 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << exp ( 1L ) ;\n"

"}";

ASSERT_EQUALS(expected_exp, tokWithNewlines(code_exp));

const char code_expf[] ="void f(float x) {\n"

" std::cout << expf(x);\n" // do not simplify

" std::cout << expf(-1.0);\n" // do not simplify

" std::cout << expf(0.0);\n" // simplify to 1

" std::cout << expf(1.0);\n" // do not simplify

"}";

const char expected_expf[] = "void f ( float x ) {\n"

"std :: cout << expf ( x ) ;\n"

"std :: cout << expf ( -1.0 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << expf ( 1.0 ) ;\n"

"}";

ASSERT_EQUALS(expected_expf, tokWithNewlines(code_expf));

const char code_expl[] ="void f(long double x) {\n"

" std::cout << expl(x);\n" // do not simplify

" std::cout << expl(-1.0);\n" // do not simplify

" std::cout << expl(0.0);\n" // simplify to 1

" std::cout << expl(1.0);\n" // do not simplify

"}";

const char expected_expl[] = "void f ( double x ) {\n"

"std :: cout << expl ( x ) ;\n"

"std :: cout << expl ( -1.0 ) ;\n"

"std :: cout << 1 ;\n"

"std :: cout << expl ( 1.0 ) ;\n"

"}";

ASSERT_EQUALS(expected_expl, tokWithNewlines(code_expl));

}

void simplifyMathFunctions_erf() {

// verify erf(), erff(), erfl() - simplifcation

const char code_erf[] ="void f(int x) {\n"

" std::cout << erf(x);\n" // do not simplify

" std::cout << erf(10);\n" // do not simplify

" std::cout << erf(0L);\n" // simplify to 0

"}";

const char expected_erf[] = "void f ( int x ) {\n"

"std :: cout << erf ( x ) ;\n"

"std :: cout << erf ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_erf, tokWithNewlines(code_erf));

const char code_erff[] ="void f(float x) {\n"

" std::cout << erff(x);\n" // do not simplify

" std::cout << erff(10);\n" // do not simplify

" std::cout << erff(0.0f);\n" // simplify to 0

"}";

const char expected_erff[] = "void f ( float x ) {\n"

"std :: cout << erff ( x ) ;\n"

"std :: cout << erff ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_erff, tokWithNewlines(code_erff));

const char code_erfl[] ="void f(long double x) {\n"

" std::cout << erfl(x);\n" // do not simplify

" std::cout << erfl(10.0f);\n" // do not simplify

" std::cout << erfl(0.0f);\n" // simplify to 0

"}";

const char expected_erfl[] = "void f ( double x ) {\n"

"std :: cout << erfl ( x ) ;\n"

"std :: cout << erfl ( 10.0f ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_erfl, tokWithNewlines(code_erfl));

}

void simplifyMathFunctions_atanh() {

// verify atanh(), atanhf(), atanhl() - simplifcation

const char code_atanh[] ="void f(int x) {\n"

" std::cout << atanh(x);\n" // do not simplify

" std::cout << atanh(10);\n" // do not simplify

" std::cout << atanh(0L);\n" // simplify to 0

"}";

const char expected_atanh[] = "void f ( int x ) {\n"

"std :: cout << atanh ( x ) ;\n"

"std :: cout << atanh ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atanh, tokWithNewlines(code_atanh));

const char code_atanhf[] ="void f(float x) {\n"

" std::cout << atanhf(x);\n" // do not simplify

" std::cout << atanhf(10);\n" // do not simplify

" std::cout << atanhf(0.0f);\n" // simplify to 0

"}";

const char expected_atanhf[] = "void f ( float x ) {\n"

"std :: cout << atanhf ( x ) ;\n"

"std :: cout << atanhf ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atanhf, tokWithNewlines(code_atanhf));

const char code_atanhl[] ="void f(long double x) {\n"

" std::cout << atanhl(x);\n" // do not simplify

" std::cout << atanhl(10.0f);\n" // do not simplify

" std::cout << atanhl(0.0d);\n" // do not simplify - invalid number!

" std::cout << atanhl(0.0f);\n" // simplify to 0

"}";

const char expected_atanhl[] = "void f ( double x ) {\n"

"std :: cout << atanhl ( x ) ;\n"

"std :: cout << atanhl ( 10.0f ) ;\n"

"std :: cout << atanhl ( 0.0d ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atanhl, tokWithNewlines(code_atanhl));

}

void simplifyMathFunctions_atan() {

// verify atan(), atanf(), atanl() - simplifcation

const char code_atan[] ="void f(int x) {\n"

" std::cout << atan(x);\n" // do not simplify

" std::cout << atan(10);\n" // do not simplify

" std::cout << atan(0L);\n" // simplify to 0

"}";

const char expected_atan[] = "void f ( int x ) {\n"

"std :: cout << atan ( x ) ;\n"

"std :: cout << atan ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atan, tokWithNewlines(code_atan));

const char code_atanf[] ="void f(float x) {\n"

" std::cout << atanf(x);\n" // do not simplify

" std::cout << atanf(10);\n" // do not simplify

" std::cout << atanf(0.0f);\n" // simplify to 0

"}";

const char expected_atanf[] = "void f ( float x ) {\n"

"std :: cout << atanf ( x ) ;\n"

"std :: cout << atanf ( 10 ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atanf, tokWithNewlines(code_atanf));

const char code_atanl[] ="void f(long double x) {\n"

" std::cout << atanl(x);\n" // do not simplify

" std::cout << atanl(10.0f);\n" // do not simplify

" std::cout << atanl(0.0f);\n" // simplify to 0

"}";

const char expected_atanl[] = "void f ( double x ) {\n"

"std :: cout << atanl ( x ) ;\n"

"std :: cout << atanl ( 10.0f ) ;\n"

"std :: cout << 0 ;\n"

"}";

ASSERT_EQUALS(expected_atanl, tokWithNewlines(code_atanl));

}