TestUnusedVar() : TestFixture("TestUnusedVar") {}

Settings settings;

void run() override {

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

settings.severity.enable(Severity::information);

settings.checkLibrary = true;

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

TEST_CASE(isRecordTypeWithoutSideEffects);

TEST_CASE(cleanFunction);

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(structmember12); // #7179 - FP unused structmember

TEST_CASE(structmember13); // #3088 - __attribute__((packed))

TEST_CASE(structmember14); // #6508 - (struct x){1,2,..}

TEST_CASE(structmember15); // #3088 - #pragma pack(1)

TEST_CASE(structmember_sizeof);

TEST_CASE(structmember16); // #10485

TEST_CASE(structmember17); // #10591

TEST_CASE(structmember18); // #10684

TEST_CASE(structmember19); // #10826, #10848, #10852

TEST_CASE(structmember20); // #10737

TEST_CASE(structmember21); // #4759

TEST_CASE(structmember22); // #11016

TEST_CASE(localvar1);

TEST_CASE(localvar2);

TEST_CASE(localvar3);

TEST_CASE(localvar4);

TEST_CASE(localvar5);

TEST_CASE(localvar6);

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 #3603

TEST_CASE(localvar42); // ticket #3742

TEST_CASE(localvar43); // ticket #3602

TEST_CASE(localvar44); // ticket #4020

TEST_CASE(localvar45); // ticket #4899

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

TEST_CASE(localvar47); // ticket #6603

TEST_CASE(localvar48); // ticket #6954

TEST_CASE(localvar49); // ticket #7594

TEST_CASE(localvar50); // ticket #6261 : dostuff(cond ? buf1 : buf2)

TEST_CASE(localvar51); // ticket #8128 - FN : tok = tok->next();

TEST_CASE(localvar52);

TEST_CASE(localvar53); // continue

TEST_CASE(localvar54); // ast, {}

TEST_CASE(localvar55);

TEST_CASE(localvar56);

TEST_CASE(localvar57); // #8974 - increment

TEST_CASE(localvar58); // #9901 - increment false positive

TEST_CASE(localvar59); // #9737

TEST_CASE(localvar60);

TEST_CASE(localvar61); // #9407

TEST_CASE(localvar62); // #10824

TEST_CASE(localvar63); // #6928

TEST_CASE(localvar64); // #9997

TEST_CASE(localvar65); // #9876, #10006

TEST_CASE(localvar66); // #11143

TEST_CASE(localvar67); // #9946

TEST_CASE(localvarloops); // loops

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(localvaralias14); // ticket #5619

TEST_CASE(localvaralias15); // ticket #6315

TEST_CASE(localvaralias16);

TEST_CASE(localvaralias17); // ticket #8911

TEST_CASE(localvaralias18); // ticket #9234 - iterator

TEST_CASE(localvaralias19); // ticket #9828

TEST_CASE(localvaralias20); // ticket #10966

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(localvararray4); // ticket #4839

TEST_CASE(localvararray5); // ticket #7092

TEST_CASE(localvarstring1);

TEST_CASE(localvarstring2); // ticket #2929

TEST_CASE(localvarconst1);

TEST_CASE(localvarconst2);

TEST_CASE(localvarreturn); // ticket #9167

TEST_CASE(localvarmaybeunused);

TEST_CASE(localvarthrow); // ticket #3687

TEST_CASE(localVarStd);

TEST_CASE(localVarClass);

TEST_CASE(localVarSmartPtr);

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

TEST_CASE(localvarStruct8);

TEST_CASE(localvarStruct9);

TEST_CASE(localvarStruct10);

TEST_CASE(localvarStruct11); // 10095

TEST_CASE(localvarStruct12); // #10495

TEST_CASE(localvarStruct13); // #10398

TEST_CASE(localvarStructArray);

TEST_CASE(localvarUnion1);

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

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

TEST_CASE(localvarAssignInWhile);

TEST_CASE(localvarTemplate); // #4955 - variable is used as template parameter

TEST_CASE(localvarFuncPtr); // #7194

TEST_CASE(localvarAddr); // #7477

TEST_CASE(localvarDelete);

TEST_CASE(localvarLambda); // #8941, #8948

TEST_CASE(localvarStructuredBinding); // #10368

TEST_CASE(localvarCppInitialization);

TEST_CASE(localvarCpp11Initialization);

TEST_CASE(chainedAssignment); // #5466

TEST_CASE(crash1);

TEST_CASE(crash2);

TEST_CASE(usingNamespace); // #4585

TEST_CASE(lambdaFunction); // #5078

TEST_CASE(namespaces); // #7557

TEST_CASE(bracesInitCpp11);// #7895 - "int var{123}" initialization

TEST_CASE(argument);

TEST_CASE(argumentClass);

TEST_CASE(escapeAlias); // #9150

TEST_CASE(volatileData); // #9280

TEST_CASE(globalData);

}

#define functionVariableUsage(...) functionVariableUsage_(__FILE__, __LINE__, __VA_ARGS__)

#define checkStructMemberUsage(...) checkStructMemberUsage_(__FILE__, __LINE__, __VA_ARGS__)

void checkStructMemberUsage_(const char* file, int line, const char code[], const std::list<Directive>* directives = nullptr) {

// Clear the error buffer..

errout.str("");

Preprocessor preprocessor(settings, nullptr);

if (directives)

preprocessor.setDirectives(*directives);

// Tokenize..

Tokenizer tokenizer(&settings, this);

tokenizer.setPreprocessor(&preprocessor);

std::istringstream istr(code);

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

// Check for unused variables..

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

(checkUnusedVar.checkStructMemberUsage)();

}

void isRecordTypeWithoutSideEffects() {

functionVariableUsage(

"class A {};\n"

"void f() {\n"

" A a;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n", errout.str());

functionVariableUsage(

"class A {};\n"

"class B {\n"

"public:\n"

" A a;\n"

"};\n"

"void f() {\n"

" B b;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: b\n", errout.str());

functionVariableUsage(

"class C {\n"

"public:\n"

" C() = default;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (style) Unused variable: c\n", errout.str());

functionVariableUsage(

"class D {\n"

"public:\n"

" D() {}\n"

"};\n"

"void f() {\n"

" D d;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (style) Unused variable: d\n", errout.str());

functionVariableUsage(

"class E {\n"

"public:\n"

" uint32_t u{1};\n"

"};\n"

"void f() {\n"

" E e;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (style) Unused variable: e\n", errout.str());

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(0) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x{0} {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"int y = 0;\n"

"class F {\n"

"public:\n"

" F() : x(y) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:8]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"int y = 0;"

"class F {\n"

"public:\n"

" F() : x(++y) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"int y = 0;"

"class F {\n"

"public:\n"

" F() : x(--y) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"int y = 0;"

"class F {\n"

"public:\n"

" F() : x(y+=1) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

functionVariableUsage(

"int y = 0;"

"class F {\n"

"public:\n"

" F() : x(y-=1) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

ASSERT_EQUALS("[test.cpp:7]: (style) Unused variable: f\n", errout.str());

// non-empty constructor

functionVariableUsage(

"class F {\n"

"public:\n"

" F() {\n"

" int i = 0;\n"

" (void) i;"

" }\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

TODO_ASSERT_EQUALS("error", "", errout.str());

// side-effect variable

functionVariableUsage(

"class F {\n"

"public:\n"

" F() {\n"

" int i = 0;\n"

" (void) i;"

" }\n"

"};\n"

"class G {\n"

"public:\n"

" F f;\n"

"};\n"

"void f() {\n"

" G g;\n"

"}");

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

// side-effect variable in initialization list

functionVariableUsage(

"class F {\n"

"public:\n"

" F() {\n"

" int i = 0;\n"

" (void) i;"

" }\n"

"};\n"

"class G {\n"

"public:\n"

" G() : f(F()) {}\n"

" F f;"

"};\n"

"void f() {\n"

" G g;\n"

"}");

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

// unknown variable type

functionVariableUsage(

"class H {\n"

"public:\n"

" unknown_type u{1};\n"

"};\n"

"void f() {\n"

" H h;\n"

"}");

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

// unknown variable type in initialization list

functionVariableUsage(

"class H {\n"

"public:\n"

" H() : x{0}, u(1) {}\n"

" int x;"

" unknown_type u;\n"

"};\n"

"void f() {\n"

" H h;\n"

"}");

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

// unknown variable type used for initialization

functionVariableUsage(

"unknown_type y = 0;\n"

"class F {\n"

"public:\n"

" F() : x(y) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"int sideEffectFunc();\n"

"class F {\n"

"public:\n"

" F() : x(sideEffectFunc()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(++unknownValue) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(--unknownValue) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(unknownValue+=1) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(unknownValue-=1) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

functionVariableUsage(

"struct S {\n"

" static void f() { std::cout << \"f()\"; }\n"

" ~S() { f(); }\n"

"};\n"

"void g() {\n"

" S s;\n"

"}\n");

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

functionVariableUsage( // #11109

"class D { public: D(); };\n"

"class E { public: ~E(); };\n"

"class F {\n"

"public:\n"

" F();\n"

" ~F();\n"

"};\n"

"void f() {\n"

" D d;\n"

" E e;\n"

" F f;\n"

"}\n");

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

}

void cleanFunction() {

// unknown function

functionVariableUsage(

"class F {\n"

"public:\n"

" F() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" F f;\n"

"}");

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

// function forward declaration

functionVariableUsage(

"int func();\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// return literal

functionVariableUsage(

"int func() { return 1; }\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:8]: (style) Unused variable: c\n", errout.str());

// return variable without side effects

functionVariableUsage(

"int func() {\n"

" int x = 1;\n"

" return x;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:11]: (style) Unused variable: c\n", errout.str());

// return variable with side effects

functionVariableUsage(

"int func() {\n"

" unknown_type x = 1;\n"

" return x;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// return unknown variable

functionVariableUsage(

"int func() {\n"

" return unknown_var;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// return variable is global, but not changed

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" return x;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:11]: (style) Unused variable: c\n", errout.str());

// changing global variable in return

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" return x++;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// changing global variable in function body

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" x++;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" --x;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" x += 2;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x = 1;\n"

"int func() {\n"

" x = 2;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// global variable use in function body without change

functionVariableUsage(

"int global = 1;\n"

"int func() {\n"

" int x = global + 1;\n"

" return x;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:12]: (style) Unused variable: c\n", errout.str());

// changing global array variable in function body

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" x[0] = 4;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" *x = 2;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" *(x) = 2;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// pointer arithmetic on global array

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" *(x + 1) = 2;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x[][] = {{0, 1}, {2, 3}};\n"

"int func() {\n"

" *((x + 1) + 1) = 4;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" int local = *(x + 1);\n"

" (void) local;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:13]: (style) Unused variable: c\n", errout.str());

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" int* local = x + 2;\n"

" (void) local;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:13]: (style) Unused variable: c\n", errout.str());

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" int* local = x + 2;\n"

" return *local;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

functionVariableUsage(

"int x[] = {0, 1, 3};\n"

"int func() {\n"

" return *(x + 1);\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// changing local variable

functionVariableUsage(

"int func() {\n"

" int x = 1;\n"

" x = 2;\n"

" x++;\n"

" return x;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:13]: (style) Unused variable: c\n", errout.str());

// variable of user-defined class without side effects

functionVariableUsage(

"class A {};\n"

"A func() {\n"

" A a;\n"

" return a;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" A x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

ASSERT_EQUALS("[test.cpp:12]: (style) Unused variable: c\n", errout.str());

// variable of user-defined class with side effects

functionVariableUsage(

"class A {\n"

"public:\n"

" unknown_type u{1};\n"

"};\n"

"int func() {\n"

" A a;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// unknown type variable

functionVariableUsage(

"int func() {\n"

" unknown_type a;\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"

"void f() {\n"

" C c;\n"

"}");

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

// nested clean function call

functionVariableUsage(

"int another_func() { return 1;}\n"

"int func() {\n"

" another_func();\n"

" return 1;\n"

"}\n"

"class C {\n"

"public:\n"

" C() : x(func()) {}\n"

" int x;\n"

"};\n"