TestUnusedVar() : TestFixture("TestUnusedVar") {

}

void run() {

TEST_CASE(emptyclass); // #5355 - False positive: Variable is not assigned a value.

TEST_CASE(emptystruct); // #5355 - False positive: Variable is not assigned a value.

TEST_CASE(structmember1);

TEST_CASE(structmember2);

TEST_CASE(structmember3);

TEST_CASE(structmember4);

TEST_CASE(structmember5);

TEST_CASE(structmember6);

TEST_CASE(structmember7);

TEST_CASE(structmember8);

TEST_CASE(structmember9); // #2017 - struct is inherited

TEST_CASE(structmember_extern); // No false positives for extern structs

TEST_CASE(structmember10);

TEST_CASE(structmember11); // #4168 - initialization with {} / passed by address to unknown function

TEST_CASE(localvar1);

TEST_CASE(localvar2);

TEST_CASE(localvar3);

TEST_CASE(localvar4);

TEST_CASE(localvar5);

TEST_CASE(localvar6);

TEST_CASE(localvar7);

TEST_CASE(localvar8);

TEST_CASE(localvar9); // ticket #1605

TEST_CASE(localvar10);

TEST_CASE(localvar11);

TEST_CASE(localvar12);

TEST_CASE(localvar13); // ticket #1640

TEST_CASE(localvar14); // ticket #5

TEST_CASE(localvar15);

TEST_CASE(localvar16); // ticket #1709

TEST_CASE(localvar17); // ticket #1720

TEST_CASE(localvar18); // ticket #1723

TEST_CASE(localvar19); // ticket #1776

TEST_CASE(localvar20); // ticket #1799

TEST_CASE(localvar21); // ticket #1807

TEST_CASE(localvar22); // ticket #1811

TEST_CASE(localvar23); // ticket #1808

TEST_CASE(localvar24); // ticket #1803

TEST_CASE(localvar25); // ticket #1729

TEST_CASE(localvar26); // ticket #1894

TEST_CASE(localvar27); // ticket #2160

TEST_CASE(localvar28); // ticket #2205

TEST_CASE(localvar29); // ticket #2206 (array initialization)

TEST_CASE(localvar30);

TEST_CASE(localvar31); // ticket #2286

TEST_CASE(localvar32); // ticket #2330

TEST_CASE(localvar33); // ticket #2346

TEST_CASE(localvar34); // ticket #2368

TEST_CASE(localvar35); // ticket #2535

TEST_CASE(localvar36); // ticket #2805

TEST_CASE(localvar37); // ticket #3078

TEST_CASE(localvar38);

TEST_CASE(localvar39); // ticket #3454

TEST_CASE(localvar40); // ticket #3473

TEST_CASE(localvar41); // ticket #3481

TEST_CASE(localvar42); // ticket #3603

TEST_CASE(localvar43); // ticket #3742

TEST_CASE(localvar44); // ticket #3602

TEST_CASE(localvar45); // ticket #4020

TEST_CASE(localvar46); // ticket #4899

TEST_CASE(localvar47); // ticket #5491 (C++11 style initialization)

TEST_CASE(localvaralias1);

TEST_CASE(localvaralias2); // ticket #1637

TEST_CASE(localvaralias3); // ticket #1639

TEST_CASE(localvaralias4); // ticket #1643

TEST_CASE(localvaralias5); // ticket #1647

TEST_CASE(localvaralias6); // ticket #1729

TEST_CASE(localvaralias7); // ticket #1732

TEST_CASE(localvaralias8);

TEST_CASE(localvaralias9); // ticket #1996

TEST_CASE(localvaralias10); // ticket #2004

TEST_CASE(localvaralias11); // ticket #4423 - iterator

TEST_CASE(localvaralias12); // ticket #4394

TEST_CASE(localvaralias13); // ticket #4487

TEST_CASE(localvarasm);

TEST_CASE(localvarstatic);

TEST_CASE(localvarextern);

TEST_CASE(localvardynamic1);

TEST_CASE(localvardynamic2); // ticket #2904

TEST_CASE(localvardynamic3); // ticket #3467

TEST_CASE(localvararray1); // ticket #2780

TEST_CASE(localvararray2); // ticket #3438

TEST_CASE(localvararray3); // ticket #3980

TEST_CASE(localvarstring1);

TEST_CASE(localvarstring2); // ticket #2929

TEST_CASE(localvarconst1);

TEST_CASE(localvarconst2);

TEST_CASE(localvarthrow); // ticket #3687

TEST_CASE(localVarStd);

// Don't give false positives for variables in structs/unions

TEST_CASE(localvarStruct1);

TEST_CASE(localvarStruct2);

TEST_CASE(localvarStruct3);

TEST_CASE(localvarStruct5);

TEST_CASE(localvarStruct6);

TEST_CASE(localvarStructArray);

TEST_CASE(localvarOp); // Usage with arithmetic operators

TEST_CASE(localvarInvert); // Usage with inverted variable

TEST_CASE(localvarIf); // Usage in if

TEST_CASE(localvarIfElse); // return tmp1 ? tmp2 : tmp3;

TEST_CASE(localvarOpAssign); // a |= b;

TEST_CASE(localvarFor); // for ( ; var; )

TEST_CASE(localvarForEach); // #4155 - BOOST_FOREACH, hlist_for_each, etc

TEST_CASE(localvarShift1); // 1 >> var

TEST_CASE(localvarShift2); // x = x >> 1

TEST_CASE(localvarShift3); // x << y

TEST_CASE(localvarCast);

TEST_CASE(localvarClass);

TEST_CASE(localvarUnused);

TEST_CASE(localvarFunction); // ticket #1799

TEST_CASE(localvarIfNOT); // #3104 - if ( NOT var )

TEST_CASE(localvarAnd); // #3672

TEST_CASE(localvarSwitch); // #3744 - false positive when localvar is used in switch

TEST_CASE(localvarNULL); // #4203 - Setting NULL value is not redundant - it is safe

TEST_CASE(localvarUnusedGoto); // #4447, #4558 goto

TEST_CASE(crash1);

TEST_CASE(crash2);

TEST_CASE(usingNamespace); // #4585

}

void checkStructMemberUsage(const char code[]) {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

// Check for unused variables..

CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);

checkUnusedVar.checkStructMemberUsage();

}

// #5355 - False positive: Variable is not assigned a value.

void emptyclass() {

functionVariableUsage("class Carla {\n"

"};\n"

"class Fred : Carla {\n"

"};\n"

"void foo() {\n"

" Fred fred;\n"

" throw fred;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

// #5355 - False positive: Variable is not assigned a value.

void emptystruct() {

functionVariableUsage("struct Fred {\n"

"};\n"

"void foo() {\n"

" Fred fred;\n"

" throw fred;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember1() {

checkStructMemberUsage("struct abc\n"

"{\n"

" int a;\n"

" int b;\n"

" int c;\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (style) struct or union member 'abc::a' is never used.\n"

"[test.cpp:4]: (style) struct or union member 'abc::b' is never used.\n"

"[test.cpp:5]: (style) struct or union member 'abc::c' is never used.\n", errout.str());

}

void structmember2() {

checkStructMemberUsage("struct ABC\n"

"{\n"

" int a;\n"

" int b;\n"

" int c;\n"

"};\n"

"\n"

"void foo()\n"

"{\n"

" struct ABC abc;\n"

" int a = abc.a;\n"

" int b = abc.b;\n"

" int c = abc.c;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember3() {

checkStructMemberUsage("struct ABC\n"

"{\n"

" int a;\n"

" int b;\n"

" int c;\n"

"};\n"

"\n"

"static struct ABC abc[] = { {1, 2, 3} };\n"

"\n"

"void foo()\n"

"{\n"

" int a = abc[0].a;\n"

" int b = abc[0].b;\n"

" int c = abc[0].c;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember4() {

checkStructMemberUsage("struct ABC\n"

"{\n"

" const int a;\n"

"};\n"

"\n"

"void foo()\n"

"{\n"

" ABC abc;\n"

" if (abc.a == 2);\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember5() {

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

" void reset()\n"

" {\n"

" a = 1;\n"

" b = 2;\n"

" }\n"

"};\n"

"\n"

"void foo()\n"

"{\n"

" struct AB ab;\n"

" ab.reset();\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember6() {

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"};\n"

"\n"

"void foo(char *buf)\n"

"{\n"

" struct AB *ab = (struct AB *)&buf[10];\n"

"}");

ASSERT_EQUALS("", errout.str());

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"};\n"

"\n"

"void foo(char *buf)\n"

"{\n"

" struct AB *ab = (AB *)&buf[10];\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember7() {

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"};\n"

"\n"

"void foo(struct AB *ab)\n"

"{\n"

" ab->a = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"};\n"

"\n"

"void foo(struct AB _shuge *ab)\n"

"{\n"

" ab->a = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember8() {

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"};\n"

"\n"

"void foo(char *ab)\n"

"{\n"

" ((AB *)ab)->b = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember9() {

checkStructMemberUsage("struct base {\n"

" int a;\n"

"};\n"

"\n"

"struct derived : public base {"

"}");

ASSERT_EQUALS("", errout.str());

}

void structmember10() {

// Fred may have some useful side-effects

checkStructMemberUsage("struct abc {\n"

" Fred fred;\n"

"};");

ASSERT_EQUALS("", errout.str());

}

void structmember11() { // #4168

checkStructMemberUsage("struct abc { int x; };\n"

"struct abc s = {0};\n"

"void f() { do_something(&s); }");

ASSERT_EQUALS("", errout.str());

checkStructMemberUsage("struct abc { int x; };\n"

"struct abc s = {0};\n"

"void f() { }");

TODO_ASSERT_EQUALS("abc::x is not used", "", errout.str());

}

void structmember_extern() {

// extern struct => no false positive

checkStructMemberUsage("extern struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"} ab;\n"

"\n"

"void foo()\n"

"{\n"

" ab.b = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

// global linkage => no false positive

checkStructMemberUsage("struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"} ab;\n"

"\n"

"void foo()\n"

"{\n"

" ab.b = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

// static linkage => error message

checkStructMemberUsage("static struct AB\n"

"{\n"

" int a;\n"

" int b;\n"

"} ab;\n"

"\n"

"void foo()\n"

"{\n"

" ab.b = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) struct or union member 'AB::a' is never used.\n", errout.str());

}

void functionVariableUsage(const char code[], const char filename[]="test.cpp") {

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

if (!tokenizer.tokenize(istr, filename))

return;

// Check for unused variables..

CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);

checkUnusedVar.checkFunctionVariableUsage();

}

void localvar1() {

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i(0);\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

// if a is undefined then Cppcheck can't determine if "int i(a)" is a

// * variable declaration

// * function declaration

functionVariableUsage("void foo()\n"

"{\n"

" int i(a);\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int j = 0;\n"

" int i(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int j = 0;\n"

" int & i = j;\n"

" x(j);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int j = 0;\n"

" const int & i = j;\n"

" x(j);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int j = 0;\n"

" int & i(j);\n"

" x(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int j = 0;\n"

" const int & i(j);\n"

" x(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int * j = 0;\n"

" int * i(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int * j = 0;\n"

" const int * i(j);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" bool i = false;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" bool i = true;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" char *i;\n"

" i = fgets();\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

// undefined variables are not reported because they may be classes with constructors

functionVariableUsage("undefined foo()\n"

"{\n"

" undefined i = 0;\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("undefined foo()\n"

"{\n"

" undefined i = 0;\n"

"}\n",

"test.c");

ASSERT_EQUALS("[test.c:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = undefined;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" void * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" const void * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" struct S * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" const struct S * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" struct S & i = j;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" const struct S & i = j;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" undefined * i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0;\n"

" int j = i;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'j' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i[10] = { 0 };\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo(int n)\n"

"{\n"

" int i[n] = { 0 };\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" char i[10] = \"123456789\";\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" char *i = \"123456789\";\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0,code=10;\n"

" for(i = 0; i < 10; i++) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0,code=10,d=10;\n"

" for(i = 0; i < 10; i++) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" d = code;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0,code=10,d=10;\n"

" for(i = 0; i < 10; i++) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" g(d);\n"

" d = code;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0,code=10,d=10;\n"

" for(i = 0; i < 10; i++) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" if (i == 3) {\n"

" return d;\n"

" }\n"

" d = code;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int i = 0,a=10,b=20;\n"

" for(i = 0; i < 10; i++) {\n"

" std::cout<<a<<std::endl;\n"

" int tmp=a;\n"

" a=b;\n"

" b=tmp;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" while(code < 20) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" while(code < 20) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" d += code;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" while(code < 20) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" g(d);\n"

" d += code;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" while(code < 20) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" if (i == 3) {\n"

" return d;\n"

" }\n"

" d += code;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int a=10,b=20;\n"

" while(a != 30) {\n"

" std::cout<<a<<std::endl;\n"

" int tmp=a;\n"

" a=b;\n"

" b=tmp;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" do {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" } while(code < 20);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" do {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" d += code;\n"

" } while(code < 20);\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" do {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" g(d);\n"

" d += code;\n"

" } while(code < 20);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10,d=10;\n"

" do {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" if (i == 3) {\n"

" return d;\n"

" }\n"

" d += code;\n"

" } while(code < 20);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int a=10,b=20;\n"

" do {\n"

" std::cout<<a<<std::endl;\n"

" int tmp=a;\n"

" a=b;\n"

" b=tmp;\n"

" } while( a!=30 );\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" for(int i=0; i < 10; i++) {\n"

" if(true) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" }\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" for(int i=0; i < 10; i++) {\n"

" if(true) {\n"

" std::cout<<code<<std::endl;\n"

" }\n"

" code += 2;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" while(code < 20) {\n"

" if(true) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" }\n"

" }\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo()\n"

"{\n"

" int code=10;\n"

" do {\n"

" if(true) {\n"

" std::cout<<code<<std::endl;\n"

" code += 2;\n"

" }\n"

" } while(code < 20);\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("void foo(int j = 0) {\n" // #5985 - default function parameters should not affect checking results

" int i = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());

}

void localvar2() {

functionVariableUsage("int foo()\n"

"{\n"

" int i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("bool foo()\n"

"{\n"

" bool i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

// undefined variables are not reported because they may be classes with constructors

functionVariableUsage("undefined foo()\n"

"{\n"

" undefined i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("", errout.str());

functionVariableUsage("undefined foo()\n"

"{\n"

" undefined i;\n"

" return i;\n"

"}\n",

"test.c");

ASSERT_EQUALS("[test.c:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("undefined *foo()\n"

"{\n"

" undefined * i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("int *foo()\n"

"{\n"

" int * i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("const int *foo()\n"

"{\n"

" const int * i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("struct S *foo()\n"

"{\n"

" struct S * i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

functionVariableUsage("const struct S *foo()\n"

"{\n"

" const struct S * i;\n"

" return i;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());

// assume f() can write a

functionVariableUsage("void foo()\n"

"{\n"

" int a[10];\n"

" f(a[0]);\n"

"}");

ASSERT_EQUALS("", errout.str());

// assume f() can write a

functionVariableUsage("void foo()\n"

"{\n"

" int a[10];\n"

" f(a[0], 0);\n"

"}");

ASSERT_EQUALS("", errout.str());

// assume f() can write a

functionVariableUsage("void foo()\n"

"{\n"

" int a[10];\n"

" f(0, a[0]);\n"

"}");

ASSERT_EQUALS("", errout.str());

// assume f() can write a

functionVariableUsage("void foo()\n"

"{\n"

" int a[10];\n"

" f(0, a[0], 0);\n"

"}");

ASSERT_EQUALS("", errout.str());

// f() can not write a (not supported yet)

functionVariableUsage("void f(int i) { }\n"

"void foo()\n"

"{\n"

" int a[10];\n"

" f(a[0]);\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is not assigned a value.\n",

"", errout.str());

// f() can not write a (not supported yet)

functionVariableUsage("void f(const int & i) { }\n"

"void foo()\n"

"{\n"

" int a[10];\n"

" f(a[0]);\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is not assigned a value.\n",

"", errout.str());

// f() writes a

functionVariableUsage("void f(int & i) { }\n"

"void foo()\n"

"{\n"

" int a[10];\n"

" f(a[0]);\n"

"}");

ASSERT_EQUALS("", errout.str());

}