/*

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

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

#include "testsuite.h"

#include <sstream>

extern std::ostringstream errout;

class TestConstructors : public TestFixture {

public:

TestConstructors() : TestFixture("TestConstructors")

{ }

private:

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

// Clear the error buffer..

errout.str("");

Settings settings;

settings.inconclusive = showAll;

settings.addEnabled("style");

settings.addEnabled("warning");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList();

// Check class constructors..

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

checkClass.constructors();

}

void run() {

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

TEST_CASE(simple12); // ticket #4620

TEST_CASE(simple13); // ticket #4617

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_destructor); // No variables need to be initialized in a destructor

TEST_CASE(initvar_func_ret_func_ptr); // ticket #4449

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

}

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"

" int i;\n"

"};");

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

check("class Fred\n"

"{\n"

"public:\n"

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

" int i;\n"

"};");

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

check("class Fred\n"

"{\n"

"public:\n"

" Fred() { }\n"

" int i;\n"

"};");

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

check("struct Fred\n"

"{\n"

" Fred() { }\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (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"

" int i;\n"

"};\n"

"Fred::Fred()\n"

"{ }\n"

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

"{\n"

" i = _i;\n"

"}\n", true);

ASSERT_EQUALS("[test.cpp:7]: (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

check("class Fred {\n"

"public:\n"

" Fred() {}\n"

"private:\n"

" int x = 0;\n"

"};");

ASSERT_EQUALS("", 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() { // ticket #4617

check("class Fred {\n"

" int x;\n"

"public:\n"

" Fred() noexcept;\n"

"};");

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

check("class Fred {\n"

" int x;\n"

"public:\n"

" Fred() noexcept(true);\n"

"};");

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

check("class Fred {\n"

" int x;\n"

"public:\n"

" Fred() noexcept { x = 0; }\n"

"};");

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

check("class Fred {\n"

" int x;\n"

"public:\n"

" Fred() noexcept(true) { x = 0; }\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"

"};");

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

check("class A {\n"

" int number;\n"

"public:\n"

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

" A() {}\n"

"};", true);

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

"[test.cpp:5]: (warning, inconclusive) 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) : A() { }\n"

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

"};");

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

}

void initvar_private_constructor() {

check("class Fred\n"

"{\n"

"private:\n"

" int var;\n"

" Fred();\n"

"};\n"

"Fred::Fred()\n"

"{ }");

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

}

void initvar_copy_constructor() { // ticket #1611

check("class Fred\n"

"{\n"

"private:\n"

" std::string var;\n"

"public:\n"

" Fred() { };\n"

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

"};");

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

check("class Fred\n"

"{\n"

"private:\n"

" std::string var;\n"

"public:\n"

" Fred();\n"

" Fred(const Fred &);\n"

"};\n"

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

"Fred::Fred(const Fred &) { };");

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

check("class Fred\n"

"{\n"

"private:\n"

" std::string var;\n"

"public:\n"

" Fred() { };\n"

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

"};", true);

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

check("class Fred\n"

"{\n"

"private:\n"

" std::string var;\n"

"public:\n"

" Fred();\n"

" Fred(const Fred &);\n"

"};\n"

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

"Fred::Fred(const Fred &) { };\n", true);

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

}

void initvar_nested_constructor() { // ticket #1375

check("class A {\n"

"public:\n"

" A();\n"

" struct B {\n"

" explicit B(int x);\n"

" struct C {\n"

" explicit C(int y);\n"

" struct D {\n"

" int d;\n"

" explicit D(int z);\n"

" };\n"

" int c;\n"

" };\n"

" int b;\n"

" };\n"

"private:\n"

" int a;\n"

" B b;\n"

"};\n"

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

"A::B::B(int x){}\n"

"A::B::C::C(int y){}\n"

"A::B::C::D::D(int z){}");

// Note that the example code is not compilable. The A constructor must

// explicitly initialize A::b. A warning for A::b is not necessary.

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

"[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"

"[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"

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

check("class A {\n"

"public:\n"

" A();\n"

" struct B {\n"

" explicit B(int x);\n"

" struct C {\n"

" explicit C(int y);\n"

" struct D {\n"

" D(const D &);\n"

" int d;\n"

" };\n"

" int c;\n"

" };\n"

" int b;\n"

" };\n"

"private:\n"

" int a;\n"

" B b;\n"

"};\n"

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

"A::B::B(int x){}\n"

"A::B::C::C(int y){}\n"

"A::B::C::D::D(const A::B::C::D & d){}");

// Note that the example code is not compilable. The A constructor must

// explicitly initialize A::b. A warning for A::b is not necessary.

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

"[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"

"[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"

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

check("class A {\n"

"public:\n"

" A();\n"

" struct B {\n"

" explicit B(int x);\n"

" struct C {\n"

" explicit C(int y);\n"

" struct D {\n"

" struct E { int e; };\n"

" struct E d;\n"

" explicit D(const E &);\n"

" };\n"

" int c;\n"

" };\n"

" int b;\n"

" };\n"

"private:\n"

" int a;\n"

" B b;\n"

"};\n"

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

"A::B::B(int x){}\n"

"A::B::C::C(int y){}\n"

"A::B::C::D::D(const A::B::C::D::E & e){}");

// Note that the example code is not compilable. The A constructor must

// explicitly initialize A::b. A warning for A::b is not necessary.

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

"[test.cpp:22]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"

"[test.cpp:23]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"

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