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

const Settings settings = settingsBuilder().library("std.cfg").build();

void run() override {

mNewTemplate = true;

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

TEST_CASE(uninitvar2_func); // function calls

TEST_CASE(uninitvar2_value); // value flow

TEST_CASE(valueFlowUninit2_value);

TEST_CASE(valueFlowUninit_uninitvar2);

TEST_CASE(valueFlowUninit_functioncall);

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

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

TEST_CASE(uninitvar_ipa);

TEST_CASE(uninitvar_memberfunction);

TEST_CASE(uninitvar_nonmember); // crash in ycmd test

TEST_CASE(uninitvarDesignatedInitializers);

TEST_CASE(isVariableUsageDeref); // *p

TEST_CASE(isVariableUsageDerefValueflow); // *p

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

// whole program analysis

TEST_CASE(ctuTest);

}

struct CheckUninitVarOptions

{

bool cpp = true;

};

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

template<size_t size>

void checkUninitVar_(const char* file, int line, const char (&code)[size], const CheckUninitVarOptions& options = make_default_obj()) {

checkUninitVar_(file, line, code, settings, options.cpp);

}

template<size_t size>

void checkUninitVar_(const char* file, int line, const char (&code)[size], const Settings& settings1, bool cpp = true) {

SimpleTokenizer tokenizer(settings1, *this, cpp);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check for redundant code..

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

checkuninitvar.check();

}

// TODO: get rid of this

void checkUninitVar_(const char* file, int line, const std::string& code) {

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check for redundant code..

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

checkuninitvar.check();

}

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:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("void foo() {\n"

" int a;\n"

" b = a - c;\n"

"}");

ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: a [legacyUninitvar]\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:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

// extracttests.enable

checkUninitVar("void foo() {\n"

" int *p;\n"

" realloc(p,10);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: p [legacyUninitvar]\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:5]: (error) Uninitialized variable: p [legacyUninitvar]\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:5]: (error) Uninitialized variable: p [legacyUninitvar]\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:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" delete p;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" delete [] p;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" *p = 135;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:6]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *p;\n"

" p[0] = 135;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *x;\n"

" int y = *x;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int *x;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\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:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("void f()\n"

"{\n"

" int a;\n"

" a++;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: a [legacyUninitvar]\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:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("static void foo()\n"

"{\n"

" int i;\n"

" if (i);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: i [legacyUninitvar]\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:21]: (error) Uninitialized variable: i [legacyUninitvar]\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:29]: (error) Uninitialized variable: i [legacyUninitvar]\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:5]: (error) Uninitialized variable: i [legacyUninitvar]\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:8]: (error) Uninitialized variable: i [legacyUninitvar]\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());

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:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("int f() {\n"

" int a,b,c;\n"

" a = b = c;\n"

"}");

ASSERT_EQUALS("[test.cpp:3:0]: (error) Uninitialized variable: c [legacyUninitvar]\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",

dinit(CheckUninitVarOptions, $.cpp = false));

ASSERT_EQUALS("[test.c:4:12]: (error) Uninitialized variable: ret [legacyUninitvar]\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"

"}",

dinit(CheckUninitVarOptions, $.cpp = 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"

"}");

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

// 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:10]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("int a() {\n"

" int ret;\n"

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

"}\n",

dinit(CheckUninitVarOptions, $.cpp = false));

ASSERT_EQUALS("[test.c:3:22]: (error) Uninitialized variable: ret [legacyUninitvar]\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:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("void a() {\n"

" int ret;\n"

" a = value << ret;\n"

"}\n",

dinit(CheckUninitVarOptions, $.cpp = false));

ASSERT_EQUALS("[test.c:3:18]: (error) Uninitialized variable: ret [legacyUninitvar]\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:5]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

// #4673

checkUninitVar("void f() {\n"

" int a;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:18]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

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

" int a;\n"

" os << a;\n"

"}");

ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

checkUninitVar("void f() {\n"

" int a;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

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

" int a;\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: a [legacyUninitvar]\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:16]: (error) Memory is allocated but not initialized: p [uninitdata]\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:16]: (error) Uninitialized variable: c [legacyUninitvar]\n"

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

errout_str());

checkUninitVar("void f() {\n"

" char p[10];\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

checkUninitVar("void f() {\n"

" char p[10];\n"

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

"}");

ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: p [legacyUninitvar]\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:7]: (error) Uninitialized variable: x [legacyUninitvar]\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:5]: (error) Uninitialized variable: s [legacyUninitvar]\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:10]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());

// +=

checkUninitVar("void f()\n"

"{\n"

" int c;\n"

" c += 2;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());

checkUninitVar("void f()\n"

"{\n"

" int a[10];\n"

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

"}");

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

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"

"}", dinit(CheckUninitVarOptions, $.cpp = 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"

"}");

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:14]: (error) Uninitialized variable: x [legacyUninitvar]\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:14]: (error) Uninitialized variable: x [legacyUninitvar]\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:7]: (error) Uninitialized variable: x [legacyUninitvar]\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);

ASSERT_EQUALS("", errout_str());

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

checkUninitVar(code, dinit(CheckUninitVarOptions, $.cpp = false));

ASSERT_EQUALS("[test.c:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());

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

"void f() {\n"

" struct AB ab;\n"

" return ab;\n"

"}";

checkUninitVar(code2);

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

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

checkUninitVar(code2, dinit(CheckUninitVarOptions, $.cpp = false));

ASSERT_EQUALS("[test.c:4:12]: (error) Uninitialized variable: ab [legacyUninitvar]\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"

"}");

ASSERT_EQUALS("", errout_str());

{

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

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

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

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

"</def>";

const Settings s = settingsBuilder(settings).libraryxml(xmldata).build();

checkUninitVar("void f() {\n"

" Fred _tm;\n"

" _tm.dostuff();\n"

"}", s);

ASSERT_EQUALS("", errout_str());

}

// Ticket #7822 - Array type

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

" A a,b;\n"

" b[0] = 0;"

" return a;\n"

"}", dinit(CheckUninitVarOptions, $.cpp = 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:13]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());

checkUninitVar("void foo() {\n"

" int b;\n"

" c = b | a;\n"

"}");

ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: b [legacyUninitvar]\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:5]: (error) Uninitialized variable: p [legacyUninitvar]\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:9]: (error) Uninitialized variable: a [legacyUninitvar]\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"

"}");

ASSERT_EQUALS("", errout_str());

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

"{\n"

" Foo *p;\n"

" if (x)\n"