TestConstructors() : TestFixture("TestConstructors") {

}

Settings settings;

void check(const char code[], bool showAll = false) {

// Clear the error buffer..

errout.str("");

settings.inconclusive = showAll;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

tokenizer.simplifyTokenList2();

// Check class constructors..

CheckClass checkClass(&tokenizer, &settings, this);

checkClass.constructors();

}

void run() {

settings.addEnabled("style");

settings.addEnabled("warning");

TEST_CASE(simple1);

TEST_CASE(simple2);

TEST_CASE(simple3);

TEST_CASE(simple4);

TEST_CASE(simple5); // ticket #2560

TEST_CASE(simple6); // ticket #4085 - uninstantiated template class

TEST_CASE(simple7); // ticket #4531

TEST_CASE(simple8);

TEST_CASE(simple9); // ticket #4574

TEST_CASE(simple10); // ticket #4388

TEST_CASE(simple11); // ticket #4536, #6214

TEST_CASE(simple12); // ticket #4620

TEST_CASE(simple13); // #5498 - no constructor, c++11 assignments

TEST_CASE(simple14); // #6253 template base

TEST_CASE(noConstructor1);

TEST_CASE(noConstructor2);

TEST_CASE(noConstructor3);

TEST_CASE(noConstructor4);

TEST_CASE(noConstructor5);

TEST_CASE(noConstructor6); // ticket #4386

TEST_CASE(noConstructor7); // ticket #4391

TEST_CASE(noConstructor8); // ticket #4404

TEST_CASE(noConstructor9); // ticket #4419

TEST_CASE(noConstructor10); // ticket #6614

TEST_CASE(forwardDeclaration); // ticket #4290/#3190

TEST_CASE(initvar_with_this); // BUG 2190300

TEST_CASE(initvar_if); // BUG 2190290

TEST_CASE(initvar_operator_eq1); // BUG 2190376

TEST_CASE(initvar_operator_eq2); // BUG 2190376

TEST_CASE(initvar_operator_eq3);

TEST_CASE(initvar_operator_eq4); // ticket #2204

TEST_CASE(initvar_operator_eq5); // ticket #4119

TEST_CASE(initvar_same_classname); // BUG 2208157

TEST_CASE(initvar_chained_assign); // BUG 2270433

TEST_CASE(initvar_2constructors); // BUG 2270353

TEST_CASE(initvar_constvar);

TEST_CASE(initvar_staticvar);

TEST_CASE(initvar_union);

TEST_CASE(initvar_delegate); // ticket #4302

TEST_CASE(initvar_private_constructor); // BUG 2354171 - private constructor

TEST_CASE(initvar_copy_constructor); // ticket #1611

TEST_CASE(initvar_nested_constructor); // ticket #1375

TEST_CASE(initvar_nocopy1); // ticket #2474

TEST_CASE(initvar_nocopy2); // ticket #2484

TEST_CASE(initvar_nocopy3); // ticket #3611

TEST_CASE(initvar_with_member_function_this); // ticket #4824

TEST_CASE(initvar_destructor); // No variables need to be initialized in a destructor

TEST_CASE(initvar_func_ret_func_ptr); // ticket #4449

TEST_CASE(initvar_alias); // #6921

TEST_CASE(initvar_templateMember); // #7205

TEST_CASE(operatorEqSTL);

TEST_CASE(uninitVar1);

TEST_CASE(uninitVar2);

TEST_CASE(uninitVar3);

TEST_CASE(uninitVar4);

TEST_CASE(uninitVar5);

TEST_CASE(uninitVar6);

TEST_CASE(uninitVar7);

TEST_CASE(uninitVar8);

TEST_CASE(uninitVar9); // ticket #1730

TEST_CASE(uninitVar10); // ticket #1993

TEST_CASE(uninitVar11);

TEST_CASE(uninitVar12); // ticket #2078

TEST_CASE(uninitVar13); // ticket #1195

TEST_CASE(uninitVar14); // ticket #2149

TEST_CASE(uninitVar15);

TEST_CASE(uninitVar16);

TEST_CASE(uninitVar17);

TEST_CASE(uninitVar18); // ticket #2465

TEST_CASE(uninitVar19); // ticket #2792

TEST_CASE(uninitVar20); // ticket #2867

TEST_CASE(uninitVar21); // ticket #2947

TEST_CASE(uninitVar22); // ticket #3043

TEST_CASE(uninitVar23); // ticket #3702

TEST_CASE(uninitVar24); // ticket #3190

TEST_CASE(uninitVar25); // ticket #4789

TEST_CASE(uninitVar26);

TEST_CASE(uninitVar27); // ticket #5170 - rtl::math::setNan(&d)

TEST_CASE(uninitVar28); // ticket #6258

TEST_CASE(uninitVar29);

TEST_CASE(uninitVar30); // ticket #6417

TEST_CASE(uninitVarEnum);

TEST_CASE(uninitVarStream);

TEST_CASE(uninitVarTypedef);

TEST_CASE(uninitVarMemset);

TEST_CASE(uninitVarArray1);

TEST_CASE(uninitVarArray2);

TEST_CASE(uninitVarArray3);

TEST_CASE(uninitVarArray4);

TEST_CASE(uninitVarArray5);

TEST_CASE(uninitVarArray6);

TEST_CASE(uninitVarArray7);

TEST_CASE(uninitVarArray8);

TEST_CASE(uninitVarArray9); // ticket #6957, #6959

TEST_CASE(uninitVarArray2D);

TEST_CASE(uninitVarArray3D);

TEST_CASE(uninitVarCpp11Init1);

TEST_CASE(uninitVarCpp11Init2);

TEST_CASE(uninitVarStruct1); // ticket #2172

TEST_CASE(uninitVarStruct2); // ticket #838

TEST_CASE(uninitVarUnion1); // ticket #3196

TEST_CASE(uninitVarUnion2);

TEST_CASE(uninitMissingFuncDef); // can't expand function in constructor

TEST_CASE(privateCtor1); // If constructor is private..

TEST_CASE(privateCtor2); // If constructor is private..

TEST_CASE(function); // Function is not variable

TEST_CASE(uninitVarHeader1); // Class is defined in header

TEST_CASE(uninitVarHeader2); // Class is defined in header

TEST_CASE(uninitVarHeader3); // Class is defined in header

TEST_CASE(uninitVarPublished); // Borland C++: Variables in the published section are auto-initialized

TEST_CASE(uninitOperator); // No FP about uninitialized 'operator[]'

TEST_CASE(uninitFunction1); // No FP when initialized in function

TEST_CASE(uninitFunction2); // No FP when initialized in function

TEST_CASE(uninitFunction3); // No FP when initialized in function

TEST_CASE(uninitFunction4);

TEST_CASE(uninitFunction5);

TEST_CASE(uninitSameClassName); // No FP when two classes have the same name

TEST_CASE(uninitFunctionOverload); // No FP when there are overloaded functions

TEST_CASE(uninitVarOperatorEqual); // ticket #2415

TEST_CASE(uninitVarPointer); // ticket #3801

TEST_CASE(uninitConstVar);

TEST_CASE(constructors_crash1); // ticket #5641

TEST_CASE(classWithOperatorInName);// ticket #2827

}

void simple1() {

check("class Fred\n"

"{\n"

"public:\n"

" int i;\n"

"};");

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

check("class Fred\n"

"{\n"

"private:\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor.\n", errout.str());

check("struct Fred\n"

"{\n"

"private:\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:1]: (style) The struct 'Fred' does not have a constructor.\n", errout.str());

}

void simple2() {

check("class Fred\n"

"{\n"

"public:\n"

" Fred() : i(0) { }\n"

" Fred(Fred const & other) : i(other.i) {}\n"

" Fred(Fred && other) : i(other.i) {}\n"

" int i;\n"

"};");

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

check("class Fred\n"

"{\n"

"public:\n"

" Fred() { i = 0; }\n"

" Fred(Fred const & other) {i=other.i}\n"

" Fred(Fred && other) {i=other.i}\n"

" int i;\n"

"};");

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

check("class Fred\n"

"{\n"

"public:\n"

" Fred() { }\n"

" Fred(Fred const & other) {}\n"

" Fred(Fred && other) {}\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"

"[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"

"[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());

check("struct Fred\n"

"{\n"

" Fred() { }\n"

" Fred(Fred const & other) {}\n"

" Fred(Fred && other) {}\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"

"[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"

"[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());

}

void simple3() {

check("struct Fred\n"

"{\n"

" Fred();\n"

" int i;\n"

"};\n"

"Fred::Fred() :i(0)\n"

"{ }");

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

check("struct Fred\n"

"{\n"

" Fred();\n"

" int i;\n"

"};\n"

"Fred::Fred()\n"

"{ i = 0; }");

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

check("struct Fred\n"

"{\n"

" Fred();\n"

" int i;\n"

"};\n"

"Fred::Fred()\n"

"{ }");

ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());

}

void simple4() {

check("struct Fred\n"

"{\n"

" Fred();\n"

" explicit Fred(int _i);\n"

" Fred(Fred const & other);\n"

" int i;\n"

"};\n"

"Fred::Fred()\n"

"{ }\n"

"Fred::Fred(int _i)\n"

"{\n"

" i = _i;\n"

"}\n", true);

ASSERT_EQUALS("[test.cpp:8]: (warning, inconclusive) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());

}

void simple5() { // ticket #2560

check("namespace Nsp\n"

"{\n"

" class B { };\n"

"}\n"

"class Altren : public Nsp::B\n"

"{\n"

"public:\n"

" Altren () : Nsp::B(), mValue(0)\n"

" {\n"

" }\n"

"private:\n"

" int mValue;\n"

"};");

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

}

void simple6() { // ticket #4085 - uninstantiated template class

check("template <class T> struct A {\n"

" A<T>() { x = 0; }\n"

" A<T>(const T & t) { x = t.x; }\n"

"private:\n"

" int x;\n"

"};");

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

check("template <class T> struct A {\n"

" A<T>() : x(0) { }\n"

" A<T>(const T & t) : x(t.x) { }\n"

"private:\n"

" int x;\n"

"};");

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

check("template <class T> struct A {\n"

" A<T>() : x(0) { }\n"

" A<T>(const T & t) : x(t.x) { }\n"

"private:\n"

" int x;\n"

" int y;\n"

"};");

ASSERT_EQUALS("[test.cpp:2]: (warning) Member variable 'A::y' is not initialized in the constructor.\n"

"[test.cpp:3]: (warning) Member variable 'A::y' is not initialized in the constructor.\n", errout.str());

}

void simple7() { // ticket #4531

check("class Fred;\n"

"struct Fred {\n"

" int x;\n"

"};");

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

}

void simple8() {

check("struct Fred { int x; };\n"

"class Barney { Fred fred; };\n"

"class Wilma { struct Betty { int x; } betty; };");

ASSERT_EQUALS("[test.cpp:2]: (style) The class 'Barney' does not have a constructor.\n"

"[test.cpp:3]: (style) The class 'Wilma' does not have a constructor.\n", errout.str());

}

void simple9() { // ticket #4574

check("class Unknown::Fred {\n"

"public:\n"

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

"private:\n"

" int x;\n"

"};");

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

}

void simple10() { // ticket #4388

check("class Fred {\n"

"public:\n"

" Fred() = default;\n"

"private:\n"

" int x;\n"

"};");

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

}

void simple11() { // ticket #4536, #6214

check("class Fred {\n"

"public:\n"

" Fred() {}\n"

"private:\n"

" int x = 0;\n"

" int y = f();\n"

" int z{0};\n"

" int (*pf[2])(){nullptr, nullptr};\n"

" int a[2][3] = {{1,2,3},{4,5,6}};\n"

" int b{1}, c{2};\n"

" int d, e{3};\n"

" int f{4}, g;\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n"

"[test.cpp:3]: (warning) Member variable 'Fred::g' is not initialized in the constructor.\n", errout.str());

}

void simple12() { // ticket #4620

check("class Fred {\n"

" int x;\n"

"public:\n"

" Fred() { Init(); }\n"

" void Init(int i = 0);\n"

"};\n"

"void Fred::Init(int i) { x = i; }");

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

check("class Fred {\n"

" int x;\n"

" int y;\n"

"public:\n"

" Fred() { Init(0); }\n"

" void Init(int i, int j = 0);\n"

"};\n"

"void Fred::Init(int i, int j) { x = i; y = j; }");

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

}

void simple13() { // #5498

check("class Fred {\n"

" int x=1;\n"

" int *y=0;\n"

"};\n");

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

}

void simple14() { // #6253 template base

check("class Fred : public Base<A, B> {"

"public:"

" Fred()\n"

" :Base<A, B>(1),\n"

" x(1)\n"

" {}\n"

"private:\n"

" int x;\n"

"};\n");

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

check("class Fred : public Base<A, B> {"

"public:"

" Fred()\n"

" :Base<A, B>{1},\n"

" x{1}\n"

" {}\n"

"private:\n"

" int x;\n"

"};\n");

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

}

void noConstructor1() {

// There are nonstatic member variables - constructor is needed

check("class Fred\n"

"{\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor.\n", errout.str());

}

void noConstructor2() {

check("class Fred\n"

"{\n"

"public:\n"

" static void foobar();\n"

"};\n"

"\n"

"void Fred::foobar()\n"

"{ }");

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

}

void noConstructor3() {

check("class Fred\n"

"{\n"

"private:\n"

" static int foobar;\n"

"};");

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

}

void noConstructor4() {

check("class Fred\n"

"{\n"

"public:\n"

" int foobar;\n"

"};");

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

}

void noConstructor5() {

check("namespace Foo\n"

"{\n"

" int i;\n"

"}");

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

}

void noConstructor6() {

// ticket #4386

check("class Ccpucycles {\n"

" friend class foo::bar;\n"

" Ccpucycles() :\n"

" m_v(0), m_b(true)\n"

" {}\n"

"private:\n"

" cpucyclesT m_v;\n"

" bool m_b;\n"

"};");

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

}

void noConstructor7() {

// ticket #4391

check("short bar;\n"

"class foo;\n");

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

}

void noConstructor8() {

// ticket #4404

check("class LineSegment;\n"

"class PointArray { };\n"

"void* tech_ = NULL;\n");

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

}

void noConstructor9() {

// ticket #4419

check("class CGreeting : public CGreetingBase<char> {\n"

"public:\n"

" CGreeting() : CGreetingBase<char>(), MessageSet(false) {}\n"

"private:\n"

" bool MessageSet;\n"

"};");

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

}

void noConstructor10() {

// ticket #6614

check("class A : public wxDialog\n"

"{\n"

"private:\n"

" DECLARE_EVENT_TABLE()\n"

"public:\n"

" A(wxWindow *parent,\n"

" wxWindowID id = 1,\n"

" const wxString &title = wxT(""),\n"

" const wxPoint& pos = wxDefaultPosition,\n"

" const wxSize& size = wxDefaultSize,\n"

" long style = wxDIALOG_NO_PARENT | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCLOSE_BOX);\n"

" virtual ~A();\n"

"private:\n"

" wxTimer *WxTimer1;\n"

"};\n");

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

}

// ticket #4290 "False Positive: style (noConstructor): The class 'foo' does not have a constructor."

// ticket #3190 "SymbolDatabase: Parse of sub class constructor fails"

void forwardDeclaration() {

check("class foo;\n"

"int bar;\n");

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

check("class foo;\n"

"class foo;\n");

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

check("class foo{};\n"

"class foo;\n");

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

}

void initvar_with_this() {

check("struct Fred\n"

"{\n"

" Fred()\n"

" { this->i = 0; }\n"

" int i;\n"

"};");

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

}

void initvar_if() {

check("struct Fred\n"

"{\n"

" Fred()\n"

" {\n"

" if (true)\n"

" i = 0;\n"

" else\n"

" i = 1;\n"

" }\n"

" int i;\n"

"};");

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

}

void initvar_operator_eq1() {

// Bug 2190376 and #3820 - False positive, Uninitialized member variable with operator=

check("struct Fred\n"

"{\n"

" int i;\n"

"\n"

" Fred()\n"

" { i = 0; }\n"

"\n"

" Fred(const Fred &fred)\n"

" { *this = fred; }\n"

"\n"

" const Fred & operator=(const Fred &fred)\n"

" { i = fred.i; return *this; }\n"

"};");

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

check("struct Fred {\n"

" int i;\n"

"\n"

" Fred(const Fred &fred)\n"

" { (*this) = fred; }\n"

"\n"

" const Fred & operator=(const Fred &fred)\n"

" { i = fred.i; return *this; }\n"

"};");

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

check("struct A\n"

"{\n"

" A() : i(0), j(0) {}\n"

"\n"

" A &operator=(const int &value)\n"

" {\n"

" i = value;\n"

" return (*this);\n"

" }\n"

"\n"

" int i;\n"

" int j;\n"

"};");

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

}

void initvar_operator_eq2() {

check("struct Fred\n"

"{\n"

" Fred() { i = 0; }\n"

" void operator=(const Fred &fred) { }\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());

}

void initvar_operator_eq3() {

check("struct Fred\n"

"{\n"

" Fred() { Init(); }\n"

" void operator=(const Fred &fred) { Init(); }\n"

"private:\n"

" void Init() { i = 0; }\n"

" int i;\n"

"};");

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

}

void initvar_operator_eq4() {

check("class Fred\n"

"{\n"

" int i;\n"

"public:\n"

" Fred() : i(5) { }\n"

" Fred & operator=(const Fred &fred)\n"

" {\n"

" if (&fred != this)\n"

" {\n"

" }\n"

" return *this\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());

check("class Fred\n"

"{\n"

" int * i;\n"

"public:\n"

" Fred() : i(NULL) { }\n"

" Fred & operator=(const Fred &fred)\n"

" {\n"

" if (&fred != this)\n"

" {\n"

" }\n"

" return *this\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());

check("class Fred\n"

"{\n"

" const int * i;\n"

"public:\n"

" Fred() : i(NULL) { }\n"

" Fred & operator=(const Fred &fred)\n"

" {\n"

" if (&fred != this)\n"

" {\n"

" }\n"

" return *this\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());

check("class Fred\n"

"{\n"

" const int i;\n"

"public:\n"

" Fred() : i(5) { }\n"

" Fred & operator=(const Fred &fred)\n"

" {\n"

" if (&fred != this)\n"

" {\n"

" }\n"

" return *this\n"

" }\n"

"};");

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

}

void initvar_operator_eq5() { // #4119 - false positive when using swap to assign variables

check("class Fred {\n"

" int i;\n"

"public:\n"

" Fred() : i(5) { }\n"

" ~Fred() { }\n"

" Fred(const Fred &fred) : i(fred.i) { }\n"

" Fred & operator=(const Fred &rhs) {\n"

" Fred(rhs).swap(*this);\n"

" return *this;\n"

" }\n"

"};");

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

}

void initvar_same_classname() {

// Bug 2208157 - False positive: Uninitialized variable, same class name

check("void func1()\n"

"{\n"

" class Fred\n"

" {\n"

" int a;\n"

" Fred() { a = 0; }\n"

" };\n"

"}\n"

"\n"

"void func2()\n"

"{\n"

" class Fred\n"

" {\n"

" int b;\n"

" Fred() { b = 0; }\n"

" };\n"

"}");

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

check("void func1()\n"

"{\n"

" struct Fred\n"

" {\n"

" int a;\n"

" Fred() { a = 0; }\n"

" };\n"

"}\n"

"\n"

"void func2()\n"

"{\n"

" class Fred\n"

" {\n"

" int b;\n"

" Fred() { b = 0; }\n"

" };\n"

"}");

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

check("void func1()\n"

"{\n"

" struct Fred\n"

" {\n"

" int a;\n"

" Fred() { a = 0; }\n"

" };\n"

"}\n"

"\n"

"void func2()\n"

"{\n"

" struct Fred\n"

" {\n"

" int b;\n"

" Fred() { b = 0; }\n"

" };\n"

"}");

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

check("class Foo {\n"

" void func1()\n"

" {\n"

" struct Fred\n"

" {\n"

" int a;\n"

" Fred() { a = 0; }\n"

" };\n"

" }\n"

"\n"

" void func2()\n"

" {\n"

" struct Fred\n"

" {\n"

" int b;\n"

" Fred() { b = 0; }\n"

" };\n"

" }\n"

"};");

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

check("class Foo {\n"

" void func1()\n"

" {\n"

" struct Fred\n"

" {\n"

" int a;\n"

" Fred() { }\n"

" };\n"

" }\n"

"\n"

" void func2()\n"

" {\n"

" struct Fred\n"

" {\n"

" int b;\n"

" Fred() { }\n"

" };\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::a' is not initialized in the constructor.\n"

"[test.cpp:16]: (warning) Member variable 'Fred::b' is not initialized in the constructor.\n", errout.str());

}

void initvar_chained_assign() {

// Bug 2270433 - Uninitialized variable false positive on chained assigns

check("struct c\n"

"{\n"

" c();\n"

"\n"

" int m_iMyInt1;\n"

" int m_iMyInt2;\n"

"}\n"

"\n"

"c::c()\n"

"{\n"

" m_iMyInt1 = m_iMyInt2 = 0;\n"

"}");

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

}

void initvar_2constructors() {

check("struct c\n"

"{\n"

" c();\n"

" explicit c(bool b);"

"\n"

" void InitInt();\n"

"\n"

" int m_iMyInt;\n"

" int m_bMyBool;\n"

"}\n"

"\n"

"c::c()\n"

"{\n"

" m_bMyBool = false;\n"

" InitInt();"

"}\n"

"\n"

"c::c(bool b)\n"

"{\n"

" m_bMyBool = b;\n"

" InitInt();\n"

"}\n"

"\n"

"void c::InitInt()\n"

"{\n"

" m_iMyInt = 0;\n"

"}");

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

}

void initvar_constvar() {

check("struct Fred\n"

"{\n"

" const char *s;\n"

" Fred();\n"

"};\n"

"Fred::Fred() : s(NULL)\n"

"{ }");

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

check("struct Fred\n"

"{\n"

" const char *s;\n"

" Fred();\n"

"};\n"

"Fred::Fred()\n"

"{ s = NULL; }");

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

check("struct Fred\n"

"{\n"

" const char *s;\n"

" Fred();\n"

"};\n"

"Fred::Fred()\n"

"{ }");

ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::s' is not initialized in the constructor.\n", errout.str());

}

void initvar_staticvar() {

check("class Fred\n"

"{\n"

"public:\n"

" Fred() { }\n"

" static void *p;\n"

"};");

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

}

void initvar_union() {

check("class Fred\n"

"{\n"

" union\n"

" {\n"

" int a;\n"

" char b[4];\n"

" } U;\n"

"public:\n"

" Fred()\n"

" {\n"

" U.a = 0;\n"

" }\n"

"};");

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

check("class Fred\n"

"{\n"

" union\n"

" {\n"

" int a;\n"

" char b[4];\n"

" } U;\n"

"public:\n"

" Fred()\n"

" {\n"

" }\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Fred::U' is not initialized in the constructor.\n", "", errout.str());

}

void initvar_delegate() {

check("class A {\n"

" int number;\n"

"public:\n"

" A(int n) { }\n"

" A() : A(42) {}\n"

"};");

ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n"

"[test.cpp:5]: (warning) Member variable 'A::number' is not initialized in the constructor.\n", errout.str());

check("class A {\n"

" int number;\n"

"public:\n"

" A(int n) { number = n; }\n"

" A() : A(42) {}\n"

"};");