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

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

// Simplify "?:"

TEST_CASE(simplifyConditionOperator);

// Simplify calculations

TEST_CASE(calculations);

TEST_CASE(comparisons);

TEST_CASE(simplifyCalculations);

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 #2304 - known value for strcpy parameter

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(simplifyKnownVariables57); // ticket #4724

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

if (simplify)

tokenizer.simplifyTokenList2();

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

if (simplify)

tokenizer.simplifyTokenList2();

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

}

#define tokWithNewlines(code) tokWithNewlines_(code, __FILE__, __LINE__)

std::string tokWithNewlines_(const char code[], const char* file, int line) {

errout.str("");

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList2();

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

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

}

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

if (simplify)

tokenizer.simplifyTokenList2();

// result..

return tokenizer.tokens()->stringifyList(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"

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_asinl, tokWithNewlines(code_asinl));

}

void simplifyMathFunctions_sinh() {

// verify sinh(), sinhf(), sinhl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_sinh, tokWithNewlines(code_sinh));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_sinhf, tokWithNewlines(code_sinhf));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_sinhl, tokWithNewlines(code_sinhl));

}

void simplifyMathFunctions_sin() {

// verify sin(), sinf(), sinl() - simplifcation

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_sin, tokWithNewlines(code_sin));

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

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

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

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

"}";

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

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

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

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

"}";

ASSERT_EQUALS(expected_sinf, tokWithNewlines(code_sinf));