/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "tokenize.h"

#include "checkuninitvar.h"

#include "testsuite.h"

#include <sstream>

extern std::ostringstream errout;

class TestUninitVar : public TestFixture {

public:

TestUninitVar() : TestFixture("TestUninitVar") {

}

private:

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(syntax_error); // Ticket #5073

// Test that std.cfg is configured correctly

TEST_CASE(stdcfg);

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

}

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

checkUninitVar("void foo() {\n"

" int *p;\n"

" realloc(p,10);\n"

"}");

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

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

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

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

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

"}");

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

checkUninitVar("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());

checkUninitVar("void foo()\n"

"{\n"

" int x;\n"

" int *y = &x;\n"

"}");

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

checkUninitVar("void foo()\n"

"{\n"

" int *x;\n"

" int *&y = x;\n"

"}");

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

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("static void foo()\n"

"{\n"

" int x, y;\n"

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

" int z = y * 2;\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());

checkUninitVar("static void foo()\n"

"{\n"

" Foo p;\n"

" p.abcd();\n"

"}");

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

checkUninitVar("static void foo()\n"

"{\n"

" Foo p;\n"

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

"}");

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

// Unknown types

{

checkUninitVar("void a()\n"

"{\n"

" A ret;\n"

" return ret;\n"

"}");

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

checkUninitVar("void a()\n"

"{\n"

" A ret;\n"

" return ret;\n"

"}\n",

"test.c");

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

// #3916 - avoid false positive

checkUninitVar("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());

}

checkUninitVar("void a()\n"

"{\n"

" int x[10];\n"

" int *y = x;\n"

"}");

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

checkUninitVar("void a()\n"

"{\n"

" int x;\n"

" int *y = &x;\n"

" *y = 0;\n"

" x++;\n"

"}");

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

checkUninitVar("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());

// #5255

checkUninitVar("struct Element {\n"

" static void abcd() {}\n"

"};\n"

"void a() {\n"

" Element *e;\n"

" e->abcd();\n"

"}");

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

// Handling >> and <<

{

checkUninitVar("int a() {\n"

" int ret;\n"

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

" ret++;\n"

"}");

ASSERT_EQUALS("", 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());

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

" Node node;\n"

" int x;\n"

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

"}");

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

checkUninitVar("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

checkUninitVar("void f() {\n"

" int a;\n"

" a << 1;\n"

" return a;\n"

"}");

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

}

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

" int x;\n"

" asm();\n"

" x++;\n"

"}");

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

checkUninitVar("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

checkUninitVar("char a()\n"

"{\n"

" char key;\n"

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

" init(&msg);\n"

" key++;\n"

"}");

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

checkUninitVar("void foo()\n"

"{\n"

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

" struct ABC *abc = buf;\n"

"}");

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

checkUninitVar("class Fred {\n"

"public:\n"

" FILE *f;\n"

" ~Fred();\n"

"}\n"

"Fred::~Fred()\n"

"{\n"

" fclose(f);\n"

"}");

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

checkUninitVar("void f()\n"

"{\n"

" int c;\n"

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

" if (c);\n"

"}");

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

checkUninitVar("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..

checkUninitVar("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());

checkUninitVar("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..

checkUninitVar("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());

checkUninitVar("int foo()\n"

"{\n"

" int i;\n"

" goto exit;\n"

" i++;\n"

"exit:\n"

"}");

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

// Ticket #3480 - Don't crash garbage code

ASSERT_THROW(checkUninitVar("int f()\n"

"{\n"

" return if\n"

"}"), InternalError);

// Ticket #3873 (false positive)

checkUninitVar("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

checkUninitVar("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

checkUninitVar("int f() {\n"

" int i = 0;\n"

" int j{ i };\n"

" return j;\n"

"}");

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

}

void uninitvar3() { // #3844

// avoid false positive

checkUninitVar("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() {

checkUninitVar("void foo() {\n"

" int b;\n"

" c = a | b;\n"

"}");

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

checkUninitVar("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() {

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("void f()\n"

"{\n"

" C *c;\n"

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

" c->Release();\n"

"}");

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

checkUninitVar("void f() {\n"

" char a[10];\n"

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

"}");

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

checkUninitVar("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

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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("", errout.str());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

checkUninitVar("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());

// ; { .. }

checkUninitVar("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());

checkUninitVar("void foo()\n"

"{\n"

" {\n"

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

" { }\n"

" }\n"

"\n"

" { }\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());

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

"{\n"

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

" {\n"

" }\n"

"}");

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

checkUninitVar("void f()\n"

"{\n"

" char *c1;\n"

" c1=strcpy(c1,\"test\");\n"

"}");

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

checkUninitVar("void f(char *c1)\n"

"{\n"

" c1=strcpy(c1,\"test\");\n"

"}");

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

}

// handling for/while loops..

void uninitvar_loops() {

// for..

checkUninitVar("void f()\n"

"{\n"

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

" int a;\n"

" b(4*a);\n"

" }"

"}");

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

checkUninitVar("void f() {\n"

" int k;\n"

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

" k = k + 2;\n"

" }\n"

"}");

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

checkUninitVar("void f() {\n"

" gchar sel[10];\n"

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

" int sz = sizeof(sel);\n"

" }\n"

"}");

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

checkUninitVar("enum ABCD { A, B, C, D };\n"

"\n"

"static void f(char *str ) {\n"

" enum ABCD i;\n"

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

" str[i] = 0;\n"

" }\n"

"}");

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

checkUninitVar("void x() {\n"

" do {\n"

" Token * tok;\n"

" for (tok = a; tok; tok = tok->next())\n"

" {\n"

" }\n"

" } while (tok2);\n"

"}");

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

// while..

checkUninitVar("int f()\n"

"{\n"

" int i;\n"

" while (fgets())\n"

" i = 1;\n"

" return i;"

"}");

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

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

"{\n"

" int a;\n"

" while (i < 10)\n"

" i++;\n"

" a++;"

"}");

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

// Ticket #2226: C++0x loop

checkUninitVar("void f() {\n"

" container c;\n"

" for (iterator it : c) {\n"