/*

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

* Copyright (C) 2007-2023 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 "check.h"

#include "checkuninitvar.h"

#include "ctu.h"

#include "errortypes.h"

#include "library.h"

#include "settings.h"

#include "fixture.h"

#include "tokenize.h"

#include <list>

#include <sstream>

#include <string>

class TestUninitVar : public TestFixture {

public:

TestUninitVar() : TestFixture("TestUninitVar") {}

private:

Settings settings;

void run() override {

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

TEST_CASE(uninitvar1);

TEST_CASE(uninitvar_warn_once); // only write 1 warning at a time

TEST_CASE(uninitvar_decl); // handling various types in C and C++ files

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_assign); // = {..}

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

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

TEST_CASE(uninitvar_ignore); // ignore cast, *&x, ..

TEST_CASE(uninitvar2);

TEST_CASE(uninitvar3); // #3844

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

TEST_CASE(uninitvar5); // #3861

TEST_CASE(uninitvar2_func); // function calls

TEST_CASE(uninitvar2_value); // value flow

TEST_CASE(valueFlowUninit2_value);

TEST_CASE(uninitStructMember); // struct members

TEST_CASE(uninitvar2_while);

TEST_CASE(uninitvar2_4494); // #4494

TEST_CASE(uninitvar2_malloc); // malloc returns uninitialized data

TEST_CASE(uninitvar8); // ticket #6230

TEST_CASE(uninitvar9); // ticket #6424

TEST_CASE(uninitvar10); // ticket #9467

TEST_CASE(uninitvar11); // ticket #9123

TEST_CASE(uninitvar12); // #10218 - stream read

TEST_CASE(uninitvar13); // #9772

TEST_CASE(uninitvar_unconditionalTry);

TEST_CASE(uninitvar_funcptr); // #6404

TEST_CASE(uninitvar_operator); // #6680

TEST_CASE(uninitvar_ternaryexpression); // #4683

TEST_CASE(uninitvar_pointertoarray);

TEST_CASE(uninitvar_cpp11ArrayInit); // #7010

TEST_CASE(uninitvar_rangeBasedFor); // #7078

TEST_CASE(uninitvar_static); // #8734

TEST_CASE(uninitvar_configuration);

TEST_CASE(checkExpr);

TEST_CASE(trac_4871);

TEST_CASE(syntax_error); // Ticket #5073

TEST_CASE(trac_5970);

TEST_CASE(valueFlowUninitTest);

TEST_CASE(valueFlowUninitBreak);

TEST_CASE(valueFlowUninitStructMembers);

TEST_CASE(uninitvar_ipa);

TEST_CASE(uninitvar_memberfunction);

TEST_CASE(uninitvar_nonmember); // crash in ycmd test

TEST_CASE(isVariableUsageDeref); // *p

TEST_CASE(isVariableUsageDerefValueflow); // *p

TEST_CASE(uninitvar_memberaccess); // (&(a))->b <=> a.b

// whole program analysis

TEST_CASE(ctuTest);

}

#define checkUninitVar(...) checkUninitVar_(__FILE__, __LINE__, __VA_ARGS__)

void checkUninitVar_(const char* file, int line, const char code[], const char fname[] = "test.cpp", bool debugwarnings = false) {

// Clear the error buffer..

errout.str("");

// Tokenize..

settings.debugwarnings = debugwarnings;

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, fname), file, line);

// Check for redundant code..

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

checkuninitvar.check();

settings.debugwarnings = false;

settings.certainty.enable(Certainty::experimental);

}

void uninitvar1() {

// extracttests.start: int b; int c;

// 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

// extracttests.disable

checkUninitVar("void foo() {\n"

" const int a;\n"

" b = c - a;\n"

"}");

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

// extracttests.enable

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..

// extracttests.start: struct Foo { void abcd(); };

checkUninitVar("static void foo()\n"

"{\n"

" Foo *p;\n"

" p->abcd();\n"

"}");

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

// extracttests.start: template<class T> struct Foo { void abcd(); };

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

// extracttests.start: struct Foo { void* a; };

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

// extracttests.start: void bar(int);

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

"}", "test.cpp", false);

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

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

" int x, y;\n"

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

"}");

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

// Ticket #3597

checkUninitVar("void f() {\n"

" int a;\n"

" int b = 1;\n"

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

"}");

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"

"}", "test.cpp", /*debugwarnings=*/ false);

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

// extracttests.disable

{

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

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

}

// extracttests.enable

// #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"

"}",

"test.c", false);

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"

"}", "test.cpp", false);

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"

"}", "test.cpp", false);

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

// Handling >> and <<

{

checkUninitVar("int a() {\n"

" int ret;\n"

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

" ret++;\n"

"}");

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

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

" int a;\n"

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

" return a;"

"}");

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

checkUninitVar("void f() {\n"

" int ret[2];\n"

" std::cin >> ret[0];\n"

"}");

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

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

"}\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" // <- TODO initialization?

" return *p;\n"

"}");

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

checkUninitVar("void a() {\n"

" int ret;\n"

" a = value << ret;\n"

"}\n",

"test.c");

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

// #4320 says this is a FP. << is overloaded.

checkUninitVar("int f() {\n"

" int a;\n"

" a << 1;\n" // <- TODO initialization?

" return a;\n"

"}");

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

// #4673

checkUninitVar("void f() {\n"

" int a;\n"

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

"}");

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

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

" int a;\n"

" os << a;\n"

"}");

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

checkUninitVar("void f() {\n"

" int a;\n"

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

"}");

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

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

{

// #9422

checkUninitVar("void f() {\n"

" char *p = new char[10];\n"

" std::cout << (void *)p << 1;\n"

"}");

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

checkUninitVar("void f() {\n"

" char p[10];\n"

" std::cout << (void *)p << 1;\n"

"}");

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

checkUninitVar("void f() {\n"

" char *p = new char[10];\n"

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

"}");

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

checkUninitVar("void f() {\n" // #9696

" int *p = new int[10];\n"

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

"}");

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

checkUninitVar("void f() {\n"

" int i[10];\n"

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

" char c[10];\n"

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

" wchar_t w[10];\n"

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

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: c\n"

"[test.cpp:7]: (error) Uninitialized variable: w\n",

errout.str());

checkUninitVar("void f() {\n"

" char p[10];\n"

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

"}");

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

checkUninitVar("void f() {\n"

" char p[10];\n"

" std::cout << *p << 1;\n"

"}");

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

}

}

// #8494 : Overloaded & operator

checkUninitVar("void f() {\n"

" int x;\n"

" a & x;\n"

"}");

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

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

" int x;\n"

" a & x;\n"

"}");

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

checkUninitVar("void f() {\n"

" int a,b,c;\n"

" ar & a & b & c;\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 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"

" int a[10];\n"

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

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a[1]\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"

"}", "test.cpp", false);

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"

"}", "test.cpp", false);

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

checkUninitVar("int foo() {\n"

" int x,y=0;\n"

"again:\n"

" if (y) return x;\n"

" x = a;\n"

" y = 1;\n"

" goto again;\n"

"}", "test.c", false);

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

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

"}", "test.cpp", false);

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

// Ticket #5646

checkUninitVar("float foo() {\n"

" float source[2] = {3.1, 3.1};\n"

" float (*sink)[2] = &source;\n"

" return (*sink)[0];\n"

"}");

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

// Ticket #9296

checkUninitVar("void f(void)\n"

"{\n"

" int x;\n"

" int z = (x) & ~__round_mask(1, 1);\n"

"}");

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

checkUninitVar("void f(void)\n"

"{\n"

" int x;\n"

" int z = (x) | ~__round_mask(1, 1);\n"

"}");

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

checkUninitVar("int __round_mask(int, int);\n"

"void f(void)\n"

"{\n"

" int x;\n"

" int* z = &x;\n"

"}");

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

}

void uninitvar_warn_once() {

// extracttests.start: int a; int b;

checkUninitVar("void f() {\n"

" int x;\n"

" a = x;\n"

" b = x;\n"

"}");

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

}

// Handling of unknown types. Assume they are POD in C.

void uninitvar_decl() {

const char code[] = "void f() {\n"

" dfs a;\n"

" return a;\n"

"}";

// Assume dfs is a non POD type if file is C++

checkUninitVar(code, "test.cpp");

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

// Assume dfs is a POD type if file is C

checkUninitVar(code, "test.c");

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

const char code2[] = "struct AB { int a,b; };\n"

"void f() {\n"

" struct AB ab;\n"

" return ab;\n"

"}";

checkUninitVar(code2, "test.cpp");

ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab.a\n"

"[test.cpp:4]: (error) Uninitialized struct member: ab.b\n", errout.str());

checkUninitVar(code2, "test.c");

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

// Ticket #3890 - False positive for std::map

checkUninitVar("void f() {\n"

" std::map<int,bool> x;\n"

" return x;\n"

"}");

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

// Ticket #3906 - False positive for std::vector pointer

checkUninitVar("void f() {\n"

" std::vector<int> *x = NULL;\n"

" return x;\n"

"}", "test.cpp", false);

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

// Ticket #6701 - Variable name is a POD type according to cfg

const char xmldata[] = "<?xml version=\"1.0\"?>\n"

"<def format=\"1\">"

" <podtype name=\"_tm\"/>"

"</def>";

ASSERT_EQUALS(true, settings.library.loadxmldata(xmldata, sizeof(xmldata)));

checkUninitVar("void f() {\n"

" Fred _tm;\n"

" _tm.dostuff();\n"

"}");

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

// Ticket #7822 - Array type

checkUninitVar("A *f() {\n"

" A a,b;\n"

" b[0] = 0;"

" return a;\n"

"}", "test.c", false);

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

// extracttests.start: int a; int c;

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

// extracttests.start: struct Foo { void abcd(); };

checkUninitVar("static void foo(int x)\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"

" int i;\n"

" if (1)\n"

" i = 11;\n"

" return i;\n"

"}");

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

checkUninitVar("int bar(int x) {\n"

" int n;\n"

" if ( x == 23)\n"

" n = 1;\n"

" else if ( x == 11 )\n"

" n = 2;\n"

" return n;\n"

"}");

TODO_ASSERT_EQUALS("error", "", 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(int x)\n" // #5503

"{\n"

" int i;\n"

" if (x < 2)\n"

" i = 22;\n"

" else if (x >= 2)\n" // condition is always true

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

"}", "test.cpp", false);

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"