TestUninitVar() : TestFixture("TestUninitVar") {

}

Settings settings;

void run() {

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

TEST_CASE(uninitvar1);

TEST_CASE(uninitvar_bitop); // using uninitialized operand in bit operation

TEST_CASE(uninitvar_alloc); // data is allocated but not initialized

TEST_CASE(uninitvar_arrays); // arrays

TEST_CASE(uninitvar_class); // class/struct

TEST_CASE(uninitvar_enum); // enum variables

TEST_CASE(uninitvar_if); // handling if

TEST_CASE(uninitvar_loops); // handling for/while

TEST_CASE(uninitvar_switch); // handling switch

TEST_CASE(uninitvar_references); // references

TEST_CASE(uninitvar_return); // return

TEST_CASE(uninitvar_strncpy); // strncpy doesn't always null-terminate

TEST_CASE(uninitvar_memset); // not null-terminated

TEST_CASE(uninitvar_memset_nonchar);

TEST_CASE(uninitvar_memset_char_access);

TEST_CASE(uninitvar_func); // analyse functions

TEST_CASE(func_uninit_var); // analyse function calls for: 'int a(int x) { return x+x; }'

TEST_CASE(func_uninit_pointer); // analyse function calls for: 'void a(int *p) { *p = 0; }'

TEST_CASE(uninitvar_typeof); // typeof

// checking for uninitialized variables without using the

// ExecutionPath functionality

TEST_CASE(uninitvar2);

TEST_CASE(uninitvar3); // #3844

TEST_CASE(uninitvar4); // #3869 (reference)

TEST_CASE(uninitvar5); // #3861

TEST_CASE(uninitvar6); // handling unknown types in C and C++ files

TEST_CASE(uninitvar2_func); // function calls

TEST_CASE(uninitvar2_value); // value flow

TEST_CASE(uninitvar2_structmembers); // struct members

TEST_CASE(uninitvar2_while);

TEST_CASE(uninitvar2_4494); // #4494

TEST_CASE(uninitvar2_malloc); // malloc returns uninitialized data

TEST_CASE(uninitvar7); // ticket #5971

TEST_CASE(uninitvar8); // ticket #6230

TEST_CASE(uninitvar9); // ticket #6424

TEST_CASE(uninitvar_unconditionalTry);

TEST_CASE(uninitvar_funcptr); // #6404

TEST_CASE(syntax_error); // Ticket #5073

TEST_CASE(uninitvar_posix_write);

TEST_CASE(uninitvar_posix_types);

// dead pointer

TEST_CASE(deadPointer);

}

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

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

tokenizer.simplifyTokenList2();

// Check code..

CheckUninitVar check(&tokenizer, &settings, this);

check.executionPaths();

}

/** New checking that doesn't rely on ExecutionPath */

void checkUninitVar2(const char code[], const char fname[] = "test.cpp", bool verify = true, bool debugwarnings = false) {

// Clear the error buffer..

errout.str("");

// Tokenize..

settings.experimental = true;

settings.debugwarnings = debugwarnings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, fname);

const std::string str1(tokenizer.tokens()->stringifyList(0, true));

tokenizer.simplifyTokenList2();

const std::string str2(tokenizer.tokens()->stringifyList(0, true));

if (verify && str1 != str2)

warnUnsimplified(str1, str2);

// Check for redundant code..

CheckUninitVar checkuninitvar(&tokenizer, &settings, this);

checkuninitvar.testrunner = true;

checkuninitvar.check();

settings.debugwarnings = false;

settings.experimental = true;

}

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

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, filename);

tokenizer.simplifyTokenList2();

// Check code..

CheckUninitVar check(&tokenizer, &settings, this);

check.check();

check.executionPaths();

}

void uninitvar1() {

// Ticket #2207 - False negative

checkUninitVar("void foo() {\n"

" int a;\n"

" b = c - a;\n"

"}");

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

checkUninitVar("void foo() {\n"

" int a;\n"

" b = a - c;\n"

"}");

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

// Ticket #6455 - some compilers allow const variables to be uninitialized

checkUninitVar("void foo() {\n"

" const int a;\n"

" b = c - a;\n"

"}");

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

checkUninitVar("void foo() {\n"

" int *p;\n"

" realloc(p,10);\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVarB("void foo() {\n" // #5240

" char *p = malloc(100);\n"

" char *tmp = realloc(p,1000);\n"

" if (!tmp) free(p);\n"

"}");

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

checkUninitVarB("void foo() {\n"

" int *p = NULL;\n"

" realloc(p,10);\n"

"}");

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

// dereferencing uninitialized pointer..

checkUninitVar("static void foo()\n"

"{\n"

" Foo *p;\n"

" p->abcd();\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" Foo<int> *p;\n"

" p->abcd();\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("void f(Foo *p)\n"

"{\n"

" int a;\n"

" p->a = malloc(4 * a);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" delete p;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" delete [] p;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" *p = 135;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" p[0] = 135;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *x;\n"

" int y = *x;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int *x;\n"

" int &y(*x);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());

checkUninitVarB("void foo()\n"

"{\n"

" int x;\n"

" int *y = &x;\n"

"}");

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

checkUninitVarB("void foo()\n"

"{\n"

" int *x;\n"

" int *&y = x;\n"

"}");

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

checkUninitVarB("void foo()\n"

"{\n"

" int x = xyz::x;\n"

"}");

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

checkUninitVar("void f()\n"

"{\n"

" int a;\n"

" a = 5 + a;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());

checkUninitVar("void f()\n"

"{\n"

" int a;\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());

checkUninitVarB("void f()\n"

"{\n"

" extern int a;\n"

" a++;\n"

"}");

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

checkUninitVar("void f()\n"

"{\n"

" int a;\n"

" bar(4 * a);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int i;\n"

" if (i);\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int i;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int i;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());

checkUninitVar("static int foo(int x)\n"

"{\n"

" int i;\n"

" if (x)\n"

" i = 0;\n"

" i++;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: i\n", errout.str());

checkUninitVar("static void foo()\n"

"{\n"

" int ar[10];\n"

" int i;\n"

" ar[i] = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: i\n", errout.str());

checkUninitVarB("static void foo()\n"

"{\n"

" int x, y;\n"

" x = (y = 10);\n"

" int z = y * 2;\n"

"}");

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

checkUninitVarB("static void foo() {\n"

" int x, y;\n"

" x = ((y) = 10);\n"

"}");

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

// Ticket #3597

checkUninitVar("int f() {\n"

" int a;\n"

" int b = 1;\n"

" (b += a) = 1;\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n","", errout.str());

checkUninitVar("int f() {\n"

" int a,b,c;\n"

" a = b = c;\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: c\n", "", errout.str());

checkUninitVarB("static void foo()\n"

"{\n"

" Foo p;\n"

" p.abcd();\n"

"}");

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

checkUninitVarB("static void foo()\n"

"{\n"

" Foo p;\n"

" int x = p.abcd();\n"

"}");

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

// Unknown types

{

checkUninitVarB("void a()\n"

"{\n"

" A ret;\n"

" return ret;\n"

"}");

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

checkUninitVar2("void a()\n"

"{\n"

" A ret;\n"

" return ret;\n"

"}\n",

"test.c");

ASSERT_EQUALS("[test.c:4]: (error) Uninitialized variable: ret\n", errout.str());

// #3916 - avoid false positive

checkUninitVarB("void f(float x) {\n"

" union lf { long l; float f; } u_lf;\n"

" float hx = (u_lf.f = (x), u_lf.l);\n"

"}\n",

"test.c");

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

}

checkUninitVarB("void a()\n"

"{\n"

" int x[10];\n"

" int *y = x;\n"

"}");

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

checkUninitVarB("void a()\n"

"{\n"

" int x;\n"

" int *y = &x;\n"

" *y = 0;\n"

" x++;\n"

"}");

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

checkUninitVarB("void a()\n"

"{\n"

" char x[10], y[10];\n"

" char *z = x;\n"

" memset(z, 0, sizeof(x));\n"

" memcpy(y, x, sizeof(x));\n"

"}");

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

// Handling >> and <<

{

checkUninitVarB("int a() {\n"

" int ret;\n"

" std::cin >> ret;\n"

" ret++;\n"

"}");

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

checkUninitVarB("void f(int b) {\n"

" int a;\n"

" std::cin >> b >> a;\n"

" return a;"

"}");

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

checkUninitVar2("void f(int i) {\n"

" int a;\n"

" i >> a;\n"

"}");

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

checkUninitVar("int a() {\n"

" int ret;\n"

" int a = value >> ret;\n"

" ret++;\n"

"}\n",

"test.c");

ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: ret\n", errout.str());

checkUninitVarB("void foo() {\n" // #3707

" Node node;\n"

" int x;\n"

" node[\"abcd\"] >> x;\n"

"}");

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

checkUninitVarB("int a(FArchive &arc) {\n" // #3060 (initialization through operator<<)

" int *p;\n"

" arc << p;\n"

" return *p;\n"

"}");

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

checkUninitVar("int a() {\n"

" int ret;\n"

" int a = value << ret;\n"

" return ret;\n"

"}\n",

"test.c");

ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: ret\n", errout.str());

// #4320

checkUninitVarB("void f() {\n"

" int a;\n"

" a << 1;\n"

" return a;\n"

"}");

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

// #4673

checkUninitVar2("void f() {\n"

" int a;\n"

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

"}");

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

checkUninitVar2("void f(std::ostringstream& os) {\n"

" int a;\n"

" os << a;\n"

"}");

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

checkUninitVar2("void f() {\n"

" int a;\n"

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

"}");

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

checkUninitVar2("void f(std::ostringstream& os) {\n"

" int a;\n"

" os << 1 << a;\n"

"}");

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

}

checkUninitVarB("void a() {\n" // asm

" int x;\n"

" asm();\n"

" x++;\n"

"}");

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

checkUninitVarB("void a()\n"

"{\n"

" int x[10];\n"

" struct xyz xyz1 = { .x = x };\n"

"}");

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

checkUninitVar("void a()\n"

"{\n"

" struct S *s;\n"

" s->x = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: s\n", errout.str());

checkUninitVar("void a()\n"

"{\n"

" struct S *s;\n"

" FOREACH() { }\n"

" s->x = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: s\n", errout.str());

checkUninitVar("void a()\n"

"{\n"

" struct S *s1;\n"

" struct S *s2;\n"

" FOREACH(s1) { }\n"

" s2->x = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: s2\n", errout.str());

// #1533

checkUninitVarB("char a()\n"

"{\n"

" char key;\n"

" struct A msg = { .buf = {&key} };\n"

" init(&msg);\n"

" key++;\n"

"}");

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

checkUninitVarB("void foo()\n"

"{\n"

" char *buf = malloc(100);\n"

" struct ABC *abc = buf;\n"

"}");

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

checkUninitVarB("class Fred {\n"

"public:\n"

" FILE *f;\n"

" ~Fred();\n"

"}\n"

"Fred::~Fred()\n"

"{\n"

" fclose(f);\n"

"}");

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

checkUninitVarB("void f()\n"

"{\n"

" int c;\n"

" ab(sizeof(xyz), &c);\n"

" if (c);\n"

"}");

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

checkUninitVarB("void f()\n"

"{\n"

" int c;\n"

" a = (f2(&c));\n"

" c++;\n"

"}");

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

checkUninitVar("void f(int a)\n"

"{\n"

" if (a) {\n"

" char *p;\n"

" *p = 0;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: p\n", errout.str());

// +=

checkUninitVar("void f()\n"

"{\n"

" int c;\n"

" c += 2;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());

checkUninitVar("void f()\n"

"{\n"

" char *s = malloc(100);\n"

" *s += 10;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: s\n", errout.str());

checkUninitVar("void f()\n"

"{\n"

" int a[10];\n"

" a[0] = 10 - a[1];\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());

// goto/setjmp/longjmp..

checkUninitVarB("void foo(int x)\n"

"{\n"

" long b;\n"

" if (g()) {\n"

" b =2;\n"

" goto found;\n"

" }\n"

"\n"

" return;\n"

"\n"

"found:\n"

" int a = b;\n"

"}");

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

checkUninitVarB("int foo()\n"

"{\n"

" jmp_buf env;\n"

" int a;\n"

" int val = setjmp(env);\n"

" if(val)\n"

" return a;\n"

" a = 1;\n"

" longjmp(env, 1);\n"

"}");

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

// macro_for..

checkUninitVarB("int foo()\n"

"{\n"

" int retval;\n"

" if (condition) {\n"

" for12(1,2) { }\n"

" retval = 1;\n"

" }\n"

" else\n"

" retval = 2;\n"

" return retval;\n"

"}");

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

checkUninitVarB("int foo()\n"

"{\n"

" int i;\n"

" goto exit;\n"

" i++;\n"

"exit:\n"

"}");

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

// Ticket #3873 (false positive)

checkUninitVarB("MachineLoopRange *MachineLoopRanges::getLoopRange(const MachineLoop *Loop) {\n"

" MachineLoopRange *&Range = Cache[Loop];\n"

" if (!Range)\n"

" Range = new MachineLoopRange(Loop, Allocator, *Indexes);\n"

" return Range;\n"

"}");

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

// #4040 - False positive

checkUninitVarB("int f(int x) {\n"

" int iter;\n"

" {\n"

" union\n"

" {\n"

" int asInt;\n"

" double asDouble;\n"

" };\n"

"\n"

" iter = x;\n"

" }\n"

" return 1 + iter;\n"

"}");

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

// C++11 style initialization

checkUninitVarB("int f() {\n"

" int i = 0;\n"

" int j{ i };\n"

" return j;\n"

"}");

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

}

void uninitvar3() { // #3844

// avoid false positive

checkUninitVarB("namespace std _GLIBCXX_VISIBILITY(default)\n"

"{\n"

"_GLIBCXX_BEGIN_NAMESPACE_CONTAINER\n"

" typedef unsigned long _Bit_type;\n"

" struct _Bit_reference\n"

" {\n"

" _Bit_type * _M_p;\n"

" _Bit_type _M_mask;\n"

" _Bit_reference(_Bit_type * __x, _Bit_type __y)\n"

" : _M_p(__x), _M_mask(__y) { }\n"

" };\n"

"}");

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

}

void uninitvar_bitop() {

checkUninitVar2("void foo() {\n"

" int b;\n"

" c = a | b;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: b\n", errout.str());

checkUninitVar2("void foo() {\n"

" int b;\n"

" c = b | a;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: b\n", errout.str());

}

// if..

void uninitvar_if() {

checkUninitVar2("static void foo()\n"

"{\n"

" Foo *p;\n"

" if (x)\n"

" p = new Foo;\n"

" p->abcd();\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: p\n", errout.str());

checkUninitVar2("static void foo(int x)\n"

"{\n"

" int a;\n"

" if (x==1);\n"

" if (x==2);\n"

" x = a;\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: a\n", errout.str());

checkUninitVarB("int foo()\n"

"{\n"

" int i;\n"

" if (x)\n"

" i = 22;\n"

" else\n"

" i = 33;\n"

" return i;\n"

"}");

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

checkUninitVarB("int foo()\n"

"{\n"

" int i;\n"

" if (x)\n"

" i = 22;\n"

" else\n"

" {\n"

" char *y = {0};\n"

" i = 33;\n"

" }\n"

" return i;\n"

"}");

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

checkUninitVarB("int foo()\n"

"{\n"

" int i;\n"

" if (x)\n"

" {\n"

" struct abc abc1 = (struct abc) { .a=0, .b=0, .c=0 };\n"

" i = 22;\n"

" }\n"

" else\n"

" {\n"

" i = 33;\n"

" }\n"

" return i;\n"

"}");

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

checkUninitVarB("static void foo(int x)\n"

"{\n"

" Foo *p;\n"

" if (x)\n"

" p = new Foo;\n"

" if (x)\n"

" p->abcd();\n"

"}");

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

checkUninitVarB("void foo(int a)\n"

"{\n"

" int n;\n"

" int condition;\n"

" if(a == 1) {\n"

" n=0;\n"

" condition=0;\n"

" }\n"

" else {\n"

" n=1;\n"

" }\n"

"\n"

" if( n == 0) {\n"

" a=condition;\n"

" }\n"

"}");

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

checkUninitVarB("void f()\n"

"{\n"

" C *c;\n"

" if (fun(&c));\n"

" c->Release();\n"

"}");

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

checkUninitVarB("void f() {\n"

" char a[10];\n"

" if (a[0] = x){}\n"

"}");

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

checkUninitVarB("int foo(int x)\n"

"{\n"

" int i;\n"

" if (one())\n"

" i = 1;\n"

" else\n"

" return 3;\n"

" return i;\n"

"}");

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

// Ticket #2207 - False positive

checkUninitVarB("void foo(int x) {\n"

" int a;\n"

" if (x)\n"

" a = 1;\n"

" if (!x)\n"

" return;\n"

" b = (c - a);\n"

"}");

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

checkUninitVarB("int foo()\n"

"{\n"

" int ret;\n"

" if (one())\n"

" ret = 1;\n"

" else\n"

" throw 3;\n"

" return ret;\n"

"}");

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

checkUninitVar2("int f(int a)\n"

"{\n"

" int ret;\n"

" if (a == 1)\n"

" ret = 1;\n"

" else\n"

" XYZ ret = 2;\n" // XYZ may be an unexpanded macro so bailout the checking of "ret".

" return ret;\n"

"}");

ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: ret\n", errout.str());

checkUninitVarB("int f(int a, int b)\n"

"{\n"

" int x;\n"

" if (a)\n"

" x = a;\n"

" else {\n"

" do { } while (f2());\n"

" x = b;\n"

" }\n"

" return x;\n"

"}");

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

checkUninitVarB("void foo(long verbose,bool bFlag)\n"

"{\n"

" double t;\n"

" if (bFlag)\n"

" {\n"

" if (verbose)\n"

" t = 1;\n"

" if (verbose)\n"

" std::cout << (12-t);\n"

" }\n"

"}");

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

checkUninitVarB("int test(int cond1, int cond2) {\n"

" int foo;\n"

" if (cond1 || cond2) {\n"

" if (cond2)\n"

" foo = 0;\n"

" }\n"

" if (cond2) {\n"

" int t = foo*foo;\n"

" }\n"

"}");

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

// ? :

checkUninitVar("static void foo(int v)\n"

"{\n"

" int x;\n"

" x = v <= 0 ? -1 : x;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());

checkUninitVarB("void foo()\n"

"{\n"

" const char *msgid1, *msgid2;\n"

" int ret = bar(&msgid1);\n"

" if (ret > 0) {\n"

" ret = bar(&msgid2);\n"

" }\n"

" ret = ret <= 0 ? -1 :\n"

" strcmp(msgid1, msgid2) == 0;\n"

"}");

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

checkUninitVar2("void foo(int a, int b)\n"

"{\n"

" int x; x = (a<b) ? 1 : 0;\n"

" int y = y;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: y\n", errout.str());

// ; { .. }

checkUninitVarB("int foo()\n"

"{\n"

" int retval;\n"

" if (condition) {\n"

" { }\n"

" retval = 1; }\n"

" else\n"

" retval = 2;\n"

" return retval;\n"

"}");

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

checkUninitVarB("void foo()\n"

"{\n"

" {\n"

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

" { }\n"

" }\n"

"\n"

" { }\n"

"}");

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

// ({ .. })

checkUninitVarB("void f() {\n"

" int x;\n"

" if (abc) { x = 123; }\n"

" else { a = ({b=c;}); x = 456; }\n"

" ++x;\n"

"}");

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

// Ticket #3098 - False negative uninitialized variable

checkUninitVar("void f()\n"

"{\n"

" char *c1,*c2;\n"

" if(strcoll(c1,c2))\n"

" {\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c1\n"

"[test.cpp:4]: (error) Uninitialized variable: c2\n", errout.str());

checkUninitVarB("void f(char *c1, char *c2)\n"

"{\n"

" if(strcoll(c1,c2))\n"