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.addEnabled("portability");

settings1.addEnabled("style");

settings_windows.addEnabled("portability");

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

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

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

TEST_CASE(removeVoidFromFunction);

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

}

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

}

void simplifyMathFunctions_tanh() {

// verify tanh(), tanhf(), tanhl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tanh, tokWithNewlines(code_tanh));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tanhf, tokWithNewlines(code_tanhf));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tanhl, tokWithNewlines(code_tanhl));

}

void simplifyMathFunctions_tan() {

// verify tan(), tanf(), tanl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tan, tokWithNewlines(code_tan));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tanf, tokWithNewlines(code_tanf));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_tanl, tokWithNewlines(code_tanl));

}

void simplifyMathFunctions_expm1() {

// verify expm1(), expm1f(), expm1l() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_expm1, tokWithNewlines(code_expm1));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_expm1f, tokWithNewlines(code_expm1f));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_expm1l, tokWithNewlines(code_expm1l));

}

void simplifyMathFunctions_asinh() {

// verify asinh(), asinhf(), asinhl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asinh, tokWithNewlines(code_asinh));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asinhf, tokWithNewlines(code_asinhf));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asinhl, tokWithNewlines(code_asinhl));

}

void simplifyMathFunctions_asin() {

// verify asin(), asinf(), asinl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asin, tokWithNewlines(code_asin));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asinf, tokWithNewlines(code_asinf));

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