TestClass() : TestFixture("TestClass") {

}

Settings settings0;

Settings settings1;

void run() OVERRIDE {

settings0.addEnabled("style");

settings1.addEnabled("warning");

// Load std.cfg configuration

{

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

"<def>\n"

" <memory>\n"

" <alloc init=\"false\">malloc</alloc>\n"

" <dealloc>free</dealloc>\n"

" </memory>\n"

" <smart-pointer class-name=\"std::shared_ptr\"/>\n"

"</def>";

tinyxml2::XMLDocument doc;

doc.Parse(xmldata, sizeof(xmldata));

settings0.library.load(doc);

settings1.library.load(doc);

}

TEST_CASE(virtualDestructor1); // Base class not found => no error

TEST_CASE(virtualDestructor2); // Base class doesn't have a destructor

TEST_CASE(virtualDestructor3); // Base class has a destructor, but it's not virtual

TEST_CASE(virtualDestructor4); // Derived class doesn't have a destructor => no error

TEST_CASE(virtualDestructor5); // Derived class has empty destructor => no error

TEST_CASE(virtualDestructor6); // only report error if base class pointer that points at derived class is deleted

TEST_CASE(virtualDestructorProtected);

TEST_CASE(virtualDestructorInherited);

TEST_CASE(virtualDestructorTemplate);

TEST_CASE(virtualDestructorInconclusive); // ticket # 5807

TEST_CASE(copyConstructor1);

TEST_CASE(copyConstructor2); // ticket #4458

TEST_CASE(copyConstructor3); // defaulted/deleted

TEST_CASE(copyConstructor4); // base class with private constructor

TEST_CASE(noOperatorEq); // class with memory management should have operator eq

TEST_CASE(noDestructor); // class with memory management should have destructor

TEST_CASE(operatorEq1);

TEST_CASE(operatorEq2);

TEST_CASE(operatorEq3); // ticket #3051

TEST_CASE(operatorEq4); // ticket #3114

TEST_CASE(operatorEq5); // ticket #3296

TEST_CASE(operatorEqRetRefThis1);

TEST_CASE(operatorEqRetRefThis2); // ticket #1323

TEST_CASE(operatorEqRetRefThis3); // ticket #1405

TEST_CASE(operatorEqRetRefThis4); // ticket #1451

TEST_CASE(operatorEqRetRefThis5); // ticket #1550

TEST_CASE(operatorEqRetRefThis6); // ticket #2479

TEST_CASE(operatorEqRetRefThis7); // ticket #5782 endless recursion

TEST_CASE(operatorEqToSelf1); // single class

TEST_CASE(operatorEqToSelf2); // nested class

TEST_CASE(operatorEqToSelf3); // multiple inheritance

TEST_CASE(operatorEqToSelf4); // nested class with multiple inheritance

TEST_CASE(operatorEqToSelf5); // ticket # 1233

TEST_CASE(operatorEqToSelf6); // ticket # 1550

TEST_CASE(operatorEqToSelf7);

TEST_CASE(operatorEqToSelf8); // ticket #2179

TEST_CASE(operatorEqToSelf9); // ticket #2592

TEST_CASE(memsetOnStruct);

TEST_CASE(memsetVector);

TEST_CASE(memsetOnClass);

TEST_CASE(memsetOnInvalid); // Ticket #5425: Crash upon invalid

TEST_CASE(memsetOnStdPodType); // Ticket #5901 - std::uint8_t

TEST_CASE(memsetOnFloat); // Ticket #5421

TEST_CASE(memsetOnUnknown); // Ticket #7183

TEST_CASE(mallocOnClass);

TEST_CASE(this_subtraction); // warn about "this-x"

// can member function be made const

TEST_CASE(const1);

TEST_CASE(const2);

TEST_CASE(const3);

TEST_CASE(const4);

TEST_CASE(const5); // ticket #1482

TEST_CASE(const6); // ticket #1491

TEST_CASE(const7);

TEST_CASE(const8); // ticket #1517

TEST_CASE(const9); // ticket #1515

TEST_CASE(const10); // ticket #1522

TEST_CASE(const11); // ticket #1529

TEST_CASE(const12); // ticket #1552

TEST_CASE(const13); // ticket #1519

TEST_CASE(const14);

TEST_CASE(const15);

TEST_CASE(const16); // ticket #1551

TEST_CASE(const17); // ticket #1552

TEST_CASE(const18);

TEST_CASE(const19); // ticket #1612

TEST_CASE(const20); // ticket #1602

TEST_CASE(const21); // ticket #1683

TEST_CASE(const22);

TEST_CASE(const23); // ticket #1699

TEST_CASE(const24); // ticket #1708

TEST_CASE(const25); // ticket #1724

TEST_CASE(const26); // ticket #1847

TEST_CASE(const27); // ticket #1882

TEST_CASE(const28); // ticket #1883

TEST_CASE(const29); // ticket #1922

TEST_CASE(const30);

TEST_CASE(const31);

TEST_CASE(const32); // ticket #1905 - member array is assigned

TEST_CASE(const33);

TEST_CASE(const34); // ticket #1964

TEST_CASE(const35); // ticket #2001

TEST_CASE(const36); // ticket #2003

TEST_CASE(const37); // ticket #2081 and #2085

TEST_CASE(const38); // ticket #2135

TEST_CASE(const39);

TEST_CASE(const40); // ticket #2228

TEST_CASE(const41); // ticket #2255

TEST_CASE(const42); // ticket #2282

TEST_CASE(const43); // ticket #2377

TEST_CASE(const44); // ticket #2595

TEST_CASE(const45); // ticket #2664

TEST_CASE(const46); // ticket #2636

TEST_CASE(const47); // ticket #2670

TEST_CASE(const48); // ticket #2672

TEST_CASE(const49); // ticket #2795

TEST_CASE(const50); // ticket #2943

TEST_CASE(const51); // ticket #3040

TEST_CASE(const52); // ticket #3048

TEST_CASE(const53); // ticket #3049

TEST_CASE(const54); // ticket #3052

TEST_CASE(const55);

TEST_CASE(const56); // ticket #3149

TEST_CASE(const57); // tickets #2669 and #2477

TEST_CASE(const58); // ticket #2698

TEST_CASE(const59); // ticket #4646

TEST_CASE(const60); // ticket #3322

TEST_CASE(const61); // ticket #5606

TEST_CASE(const62); // ticket #5701

TEST_CASE(const63); // ticket #5983

TEST_CASE(const64); // ticket #6268

TEST_CASE(const65); // ticket #8693

TEST_CASE(const66); // ticket #7714

TEST_CASE(const67); // ticket #9193

TEST_CASE(const_handleDefaultParameters);

TEST_CASE(const_passThisToMemberOfOtherClass);

TEST_CASE(assigningPointerToPointerIsNotAConstOperation);

TEST_CASE(assigningArrayElementIsNotAConstOperation);

TEST_CASE(constoperator1); // operator< can often be const

TEST_CASE(constoperator2); // operator<<

TEST_CASE(constoperator3);

TEST_CASE(constoperator4);

TEST_CASE(constoperator5); // ticket #3252

TEST_CASE(constoperator6); // ticket #8669

TEST_CASE(constincdec); // increment/decrement => non-const

TEST_CASE(constassign1);

TEST_CASE(constassign2);

TEST_CASE(constincdecarray); // increment/decrement array element => non-const

TEST_CASE(constassignarray);

TEST_CASE(constReturnReference);

TEST_CASE(constDelete); // delete member variable => not const

TEST_CASE(constLPVOID); // a function that returns LPVOID can't be const

TEST_CASE(constFunc); // a function that calls const functions can be const

TEST_CASE(constVirtualFunc);

TEST_CASE(constIfCfg); // ticket #1881 - fp when there are #if

TEST_CASE(constFriend); // ticket #1921 - fp for friend function

TEST_CASE(constUnion); // ticket #2111 - fp when there is a union

TEST_CASE(constArrayOperator); // #4406

TEST_CASE(constRangeBasedFor); // #5514

TEST_CASE(const_shared_ptr);

TEST_CASE(constPtrToConstPtr);

TEST_CASE(initializerListOrder);

TEST_CASE(initializerListUsage);

TEST_CASE(selfInitialization);

TEST_CASE(virtualFunctionCallInConstructor);

TEST_CASE(pureVirtualFunctionCall);

TEST_CASE(pureVirtualFunctionCallOtherClass);

TEST_CASE(pureVirtualFunctionCallWithBody);

TEST_CASE(pureVirtualFunctionCallPrevented);

TEST_CASE(duplInheritedMembers);

TEST_CASE(explicitConstructors);

TEST_CASE(copyCtorAndEqOperator);

TEST_CASE(override1);

TEST_CASE(overrideCVRefQualifiers);

TEST_CASE(checkThisUseAfterFree);

TEST_CASE(unsafeClassRefMember);

}

void checkCopyCtorAndEqOperator(const char code[]) {

// Clear the error log

errout.str("");

Settings settings;

settings.addEnabled("warning");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

// Check..

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

checkClass.checkCopyCtorAndEqOperator();

}

void copyCtorAndEqOperator() {

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

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

" A& operator=(const A& other) { return *this; }\n"

"};");

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

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

"};");

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

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

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

"};");

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

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

" A& operator=(const A& other) { return *this; }\n"

"};");

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

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

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

" int x;\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'copy constructor' but lack of 'operator='.\n", "", errout.str());

// TODO the error message should be clarified. It should say something like 'copy constructor is empty and will not assign i and therefore the behaviour is different to the default assignment operator'

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

" A& operator=(const A& other) { return *this; }\n"

" int x;\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'operator=' but lack of 'copy constructor'.\n", "", errout.str());

// TODO the error message should be clarified. It should say something like 'assignment operator does not assign i and therefore the behaviour is different to the default copy constructor'

checkCopyCtorAndEqOperator("class A \n"

"{ \n"

" A& operator=(const int &x) { this->x = x; return *this; }\n"

" int x;\n"

"};");

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

checkCopyCtorAndEqOperator("class A {\n"

"public:\n"

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

" A(const A & a) { x = a.x; }\n"

" A & operator = (const A & a) {\n"

" x = a.x;\n"

" return *this;\n"

" }\n"

"private:\n"

" int x;\n"

"};\n"

"class B : public A {\n"

"public:\n"

" B() { }\n"

" B(const B & b) :A(b) { }\n"

"private:\n"

" static int i;\n"

"};");

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

// #7987 - Don't show warning when there is a move constructor

checkCopyCtorAndEqOperator("struct S {\n"

" std::string test;\n"

" S(S&& s) : test(std::move(s.test)) { }\n"

" S& operator = (S &&s) {\n"

" test = std::move(s.test);\n"

" return *this;\n"

" }\n"

"};\n");

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

// #8337 - False positive in copy constructor detection

checkCopyCtorAndEqOperator("struct StaticListNode {\n"

" StaticListNode(StaticListNode*& prev) : m_next(0) {}\n"

" StaticListNode* m_next;\n"

"};");

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

}

void checkExplicitConstructors(const char code[]) {

// Clear the error log

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

// Check..

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

checkClass.checkExplicitConstructors();

}

void explicitConstructors() {

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

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

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

" explicit Class(int i) { }\n"

" explicit Class(const std::string&) { }\n"

" Class(int a, int b) { }\n"

"};");

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

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

" explicit Class(const Class& other) { }\n"

" explicit Class(Class&& other) { }\n"

" virtual int i() = 0;\n"

"};");

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

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

" Class(const Class& other) = delete;\n"

" Class(Class&& other) = delete;\n"

" virtual int i() = 0;\n"

"};");

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

checkExplicitConstructors("class Class {\n"

" Class(int i) { }\n"

"};");

ASSERT_EQUALS("[test.cpp:2]: (style) Class 'Class' has a constructor with 1 argument that is not explicit.\n", errout.str());

checkExplicitConstructors("class Class {\n"

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

" virtual int i() = 0;\n"

"};");

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

checkExplicitConstructors("class Class {\n"

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

" virtual int i() = 0;\n"

"};");

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

// #6585

checkExplicitConstructors("class Class {\n"

" private: Class(const Class&);\n"

" virtual int i() = 0;\n"

"};");

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

checkExplicitConstructors("class Class {\n"

" public: Class(const Class&);\n"

" virtual int i() = 0;\n"

"};");

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

// #7465: Error properly reported in templates

checkExplicitConstructors("template <class T> struct Test {\n"

" Test(int) : fData(0) {}\n"

" T fData;\n"

"};\n"

"int main() {\n"

" Test <int> test;\n"

" return 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) Struct 'Test < int >' has a constructor with 1 argument that is not explicit.\n", errout.str());

// #7465: No error for copy or move constructors

checkExplicitConstructors("template <class T> struct Test {\n"

" Test() : fData(0) {}\n"

" Test (const Test<T>& aOther) : fData(aOther.fData) {}\n"

" Test (Test<T>&& aOther) : fData(std::move(aOther.fData)) {}\n"

" T fData;\n"

"};\n"

"int main() {\n"

" Test <int> test;\n"

" return 0;\n"

"}");

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

// #8600

checkExplicitConstructors("struct A { struct B; };\n"

"struct A::B {\n"

" B() = default;\n"

" B(const B&) {}\n"

"};");

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

checkExplicitConstructors("struct A{"

" A(int, int y=2) {}"

"};");

ASSERT_EQUALS("[test.cpp:1]: (style) Struct 'A' has a constructor with 1 argument that is not explicit.\n", errout.str());

}

void checkDuplInheritedMembers(const char code[]) {

// Clear the error log

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings1, this);

std::istringstream istr(code);

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

// Check..

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

checkClass.checkDuplInheritedMembers();

}

void duplInheritedMembers() {

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int x;\n"

"};");

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

checkDuplInheritedMembers("class Base {\n"

" protected:\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout.str());

checkDuplInheritedMembers("class Base {\n"

" protected:\n"

" int x;\n"

"};\n"

"struct Derived : public Base {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout.str());

checkDuplInheritedMembers("class Base0 {\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

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

checkDuplInheritedMembers("class Base0 {\n"

" protected:\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:9]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n", errout.str());

checkDuplInheritedMembers("class Base0 {\n"

" protected:\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" public:\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n"

"[test.cpp:7] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base1'.\n", errout.str());

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int y;\n"

"};");

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

checkDuplInheritedMembers("class A {\n"

" int x;\n"

"};\n"

"struct B {\n"

" int x;\n"

"};");

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

// Unknown 'Base' class

checkDuplInheritedMembers("class Derived : public UnknownBase {\n"

" int x;\n"

"};");

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

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"class Derived : public Base {\n"

"};");

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

// #6692

checkDuplInheritedMembers("namespace test1 {\n"

" struct SWibble{};\n"

" typedef SWibble wibble;\n"

"}\n"

"namespace test2 {\n"

" struct SWibble : public test1::wibble {\n"

" int Value;\n"

" };\n"

"}");

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

}

void checkCopyConstructor(const char code[]) {

// Clear the error log

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

// Check..

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

checkClass.copyconstructors();

}

void copyConstructor1() {

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(const F &f) : p(f.p), c(f.c)\n"

" {\n"

" p=(char *)malloc(strlen(f.p)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" F(char *str)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,str);\n"

" }\n"

" F&operator=(const F&);\n"

" ~F();\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n", "", errout.str());

checkCopyConstructor("class F {\n"

" char *p;\n"

" F(const F &f) {\n"

" p = f.p;\n"

" }\n"

" F(char *str) {\n"

" p = malloc(strlen(str)+1);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

"[test.cpp:3] -> [test.cpp:7]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",

"[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

, errout.str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(const F &f) :p(f.p)\n"

" {\n"

" }\n"

" F(char *str)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,str);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

"[test.cpp:5] -> [test.cpp:10]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",

""

, errout.str());

checkCopyConstructor("class kalci\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" kalci()\n"

" {\n"

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

" strcpy(p,\"hello\");\n"

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

" strcpy(p,\"hello\");\n"

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

" strcpy(p,\"hello\");\n"

" }\n"

" kalci(const kalci &f)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" d=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" ~kalci();\n"

" kalci& operator=(const kalci&kalci);\n"

"};");

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

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(char *str,char *st,char *string)\n"

" {\n"

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

" strcpy(p,str);\n"

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

" strcpy(p,st);\n"

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

" strcpy(p,string);\n"

" }\n"

" F(const F &f)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:14] -> [test.cpp:11]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout.str());

checkCopyConstructor("class F {\n"

" char *c;\n"

" F(char *str,char *st,char *string) {\n"

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

" }\n"

" F(const F &f)\n"

" : p(malloc(size))\n"

" {\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

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

checkCopyConstructor("class F {\n"

" char *c;\n"

" F(char *str,char *st,char *string)\n"

" : p(malloc(size))\n"

" {\n"

" }\n"

" F(const F &f)\n"

" {\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout.str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F()\n"

" {\n"

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

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

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

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:8]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", "", errout.str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c;\n"

" const char *p,*d;\n"

" F(char *str,char *st,char *string)\n"

" {\n"

" p=str;\n"

" d=st;\n"

" c=(char *)malloc(strlen(string)+1);\n"

" strcpy(d,string);\n"

" }\n"

" F(const F &f)\n"

" {\n"

" p=f.p;\n"

" d=f.d;\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(d,f.p);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

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

checkCopyConstructor("class F : E\n"

"{\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

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

checkCopyConstructor("class E { E(E&); };\n" // non-copyable

"class F : E\n"

"{\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

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

checkCopyConstructor("class E {};\n"

"class F : E {\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("[test.cpp:5]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

checkCopyConstructor("class F {\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" F(F& f);\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

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

checkCopyConstructor("class F {\n"

" char *p;\n"

" F() : p(malloc(100)) {}\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

// #7198

checkCopyConstructor("struct F {\n"

" static char* c;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

"};");

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

}

void copyConstructor2() { // ticket #4458

checkCopyConstructor("template <class _Tp>\n"

"class Vector\n"

"{\n"

"public:\n"

" Vector() {\n"

" _M_finish = new _Tp[ 42 ];\n"

" }\n"

" Vector( const Vector<_Tp>& v ) {\n"

" }\n"

" ~Vector();\n"

" Vector& operator=(const Vector&v);\n"

" _Tp* _M_finish;\n"

"};");

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

}

void copyConstructor3() {

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f) = delete;\n"

" F&operator=(const F &f);\n"

" ~F();\n"

"};");

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

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f) = default;\n"

" F&operator=(const F &f);\n"

" ~F();\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The copy constructor is explicitly defaulted but the default copy constructor does not work well. It is recommended to define or delete the copy constructor.\n", errout.str());

}

void copyConstructor4() {

checkCopyConstructor("class noncopyable {\n"

"protected:\n"

" noncopyable() {}\n"

" ~noncopyable() {}\n"

"\n"

"private:\n"

" noncopyable( const noncopyable& );\n"

" const noncopyable& operator=( const noncopyable& );\n"

"};\n"

"\n"

"class Base : private noncopyable {};\n"

"\n"

"class Foo : public Base {\n"

"public:\n"

" Foo() : m_ptr(new int) {}\n"

" ~Foo() { delete m_ptr; }\n"

"private:\n"

" int* m_ptr;\n"

"};");

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

}

void noOperatorEq() {

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" ~F();\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' does not have a operator= which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

// defaulted operator=

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" F &operator=(const F &f) = default;\n"

" ~F();\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The operator= is explicitly defaulted but the default operator= does not work well. It is recommended to define or delete the operator=.\n", errout.str());

// deleted operator=

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" F &operator=(const F &f) = delete;\n"

" ~F();\n"

"};");

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

// base class deletes operator=

checkCopyConstructor("struct F : NonCopyable {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" ~F();\n"

"};");

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

}

void noDestructor() {

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" F&operator=(const F&);"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

checkCopyConstructor("struct F {\n"

" C* c;\n"

" F() { c = new C; }\n"

" F(const F &f);\n"

" F&operator=(const F&);"

"};");

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

checkCopyConstructor("struct F {\n"

" int* i;\n"

" F() { i = new int(); }\n"

" F(const F &f);\n"

" F& operator=(const F&);"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

checkCopyConstructor("struct Data { int x; int y; };\n"

"struct F {\n"

" Data* c;\n"

" F() { c = new Data; }\n"

" F(const F &f);\n"

" F&operator=(const F&);"

"};");

ASSERT_EQUALS("[test.cpp:4]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());

// defaulted destructor

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" F &operator=(const F &f);\n"

" ~F() = default;\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The destructor is explicitly defaulted but the default destructor does not work well. It is recommended to define the destructor.\n", errout.str());

// deleted destructor

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f);\n"

" F &operator=(const F &f);\n"

" ~F() = delete;\n"

"};");

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

}

// Check the operator Equal

void checkOpertorEq(const char code[]) {

// Clear the error log

errout.str("");

settings0.inconclusive = true;

// Tokenize..

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

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

// Check..

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

checkClass.operatorEq();

}

void operatorEq1() {

checkOpertorEq("class A\n"

"{\n"

"public:\n"

" void goo() {}"

" void operator=(const A&);\n"

"};");

ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());

checkOpertorEq("class A\n"

"{\n"

"public:\n"

" void goo() {}"

" void operator=(const A&)=delete;\n"

"};");