TestClass() : TestFixture("TestClass")

{ }

void run() {

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

TEST_CASE(uninitVarStruct1); // ticket #2172

TEST_CASE(uninitVarStruct2); // ticket #838

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(uninitSameClassName); // No FP when two classes have the same name

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

TEST_CASE(uninitJava); // Java: no FP when variable is initialized in declaration

TEST_CASE(uninitVarOperatorEqual); // ticket #2415

TEST_CASE(noConstructor1);

TEST_CASE(noConstructor2);

TEST_CASE(noConstructor3);

TEST_CASE(noConstructor4);

TEST_CASE(noConstructor5);

TEST_CASE(operatorEq1);

TEST_CASE(operatorEq2);

TEST_CASE(operatorEq3); // ticket #3051

TEST_CASE(operatorEq4); // ticket #3114

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(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(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); // ticket #1563

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 #3049

TEST_CASE(const53); // ticket #3052

TEST_CASE(const54);

TEST_CASE(const55); // ticket #3149

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(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 are union

TEST_CASE(initializerList);

}

// Check the operator Equal

void checkOpertorEq(const char code[]) {

// Clear the error log

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList();

// Check..

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

checkClass.operatorEq();

}

void operatorEq1() {

checkOpertorEq("class A\n"

"{\n"

"public:\n"

" void goo() {}"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"private:\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"public:\n"

" void goo() {}\n"

"private:\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"public:\n"

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

"};\n"

"class B\n"

"{\n"

"public:\n"

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

"};\n");

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

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

checkOpertorEq("struct A\n"

"{\n"

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

"};\n");

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

}

void operatorEq2() {

checkOpertorEq("class A\n"

"{\n"

"public:\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"public:\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"public:\n"

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

"};\n");

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

checkOpertorEq("class A\n"

"{\n"

"public:\n"

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

"};\n");

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

}

void operatorEq3() { // ticket #3051

checkOpertorEq("class A\n"

"{\n"

"public:\n"

" A * operator=(const A*);\n"

"};\n");

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

}

void operatorEq4() { // ticket #3114 (infinite loop)

checkOpertorEq("struct A {\n"

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

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

"};\n");

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

}

// Check that operator Equal returns reference to this

void checkOpertorEqRetRefThis(const char code[]) {

// Clear the error log

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList();

// Check..

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

checkClass.operatorEqRetRefThis();

}

void operatorEqRetRefThis1() {

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n");

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n");

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

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

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

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

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

"A & A::operator=(const A &a) { return a; }\n");

ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to self\n", errout.str());

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

"A & A::operator=(const A &a) { return a; }\n");

ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to self\n", errout.str());

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" B & operator=(const B &b) { return *this; }\n"

" };\n"

"};\n");

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" B & operator=(const B &b) { return b; }\n"

" };\n"

"};\n");

ASSERT_EQUALS("[test.cpp:7]: (style) 'operator=' should return reference to self\n", errout.str());

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

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

" };\n"

"};\n"

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

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

checkOpertorEqRetRefThis(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

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

" };\n"

"};\n"

"A::B & A::B::operator=(const A::B &b) { return b; }\n");

ASSERT_EQUALS("[test.cpp:10]: (style) 'operator=' should return reference to self\n", errout.str());

}

void operatorEqRetRefThis2() {

// ticket # 1323

checkOpertorEqRetRefThis(

"class szp\n"

"{\n"

" szp &operator =(int *other) {};\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should return reference to self\n", errout.str());

checkOpertorEqRetRefThis(

"class szp\n"

"{\n"

" szp &operator =(int *other);\n"

"};\n"

"szp &szp::operator =(int *other) {}");

ASSERT_EQUALS("[test.cpp:5]: (style) 'operator=' should return reference to self\n", errout.str());

}

void operatorEqRetRefThis3() {

// ticket # 1405

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

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

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

"};");

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

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

" A &operator =(int *other);\n"

" A &operator =(long *other);\n"

"};\n"

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

"A &A::operator =(long *other) { return (*this = 0); };");

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

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

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

" inline A &operator =(long *other) { return operator = (*(int *)other); };\n"

"};");

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

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

" A &operator =(int *other);\n"

" A &operator =(long *other);\n"

"};\n"

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

"A &A::operator =(long *other) { return operator = (*(int *)other); };");

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

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

" A &operator =(int *other);\n"

" A &operator =(long *other);\n"

"};\n"

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

"A &A::operator =(long *other) { return this->operator = (*(int *)other); };");

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

}

void operatorEqRetRefThis4() {

// ticket # 1451

checkOpertorEqRetRefThis(

"P& P::operator = (const P& pc)\n"

"{\n"

" return (P&)(*this += pc);\n"

"}");

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

}

void operatorEqRetRefThis5() {

// ticket # 1550

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

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

"};");

ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should return reference to self\n", errout.str());

checkOpertorEqRetRefThis(

"class A {\n"

"public:\n"

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

"};\n"

"A & A :: operator=(const A &a) { }");

ASSERT_EQUALS("[test.cpp:5]: (style) 'operator=' should return reference to self\n", errout.str());

}

void operatorEqRetRefThis6() { // ticket #2478 (segmentation fault)

checkOpertorEqRetRefThis(

"class UString {\n"

"public:\n"

" UString& assign( const char* c_str );\n"

" UString& operator=( const UString& s );\n"

"};\n"

"UString& UString::assign( const char* c_str ) {\n"

" std::string tmp( c_str );\n"

" return assign( tmp );\n"

"}\n"

"UString& UString::operator=( const UString& s ) {\n"

" return assign( s );\n"

"}\n");

}

// Check that operator Equal checks for assignment to self

void checkOpertorEqToSelf(const char code[]) {

// Clear the error log

errout.str("");

Settings settings;

settings.addEnabled("style");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList();

// Check..

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

checkClass.operatorEqToSelf();

}

void operatorEqToSelf1() {

// this test has an assignment test but it is not needed

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

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

"};\n");

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

// this test doesn't have an assignment test but it is not needed

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

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

"};\n");

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

// this test needs an assignment test and has it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

" {\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" }\n"

" return *this;\n"

" }\n"

"};\n");

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

// this class needs an assignment test but doesn't have it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" return *this;\n"

" }\n"

"};\n");

ASSERT_EQUALS("[test.cpp:5]: (warning) 'operator=' should check for assignment to self\n", errout.str());

// this test has an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

"A & A::operator=(const A &a) { if (&a != this) { } return *this; }\n");

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

// this test doesn't have an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

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

"};\n"

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

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

// this test needs an assignment test and has it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

"};\n"

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

"{\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" }\n"

" return *this;\n"

"}\n");

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

// this test needs an assignment test but doesn’t have it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

"};\n"

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

"{\n"

" free(s);\n"

" s = strdup(a.s);\n"

" return *this;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:7]: (warning) 'operator=' should check for assignment to self\n", errout.str());

// ticket #1224

checkOpertorEqToSelf(

"const SubTree &SubTree::operator= (const SubTree &b)\n"

"{\n"

" CodeTree *oldtree = tree;\n"

" tree = new CodeTree(*b.tree);\n"

" delete oldtree;\n"

" return *this;\n"

"}\n"

"const SubTree &SubTree::operator= (const CodeTree &b)\n"

"{\n"

" CodeTree *oldtree = tree;\n"

" tree = new CodeTree(b);\n"

" delete oldtree;\n"

" return *this;\n"

"}");

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

}

void operatorEqToSelf2() {

// this test has an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" B & operator=(const B &b) { if (&b != this) { } return *this; }\n"

" };\n"

"};\n");

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

// this test doesn't have an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" B & operator=(const B &b) { return *this; }\n"

" };\n"

"};\n");

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

// this test needs an assignment test but has it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" char *s;\n"

" B & operator=(const B &b)\n"

" {\n"

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

" {\n"

" }\n"

" return *this;\n"

" }\n"

" };\n"

"};\n");

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

// this test needs an assignment test but doesn't have it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" char *s;\n"

" B & operator=(const B &b)\n"

" {\n"

" free(s);\n"

" s = strdup(b.s);\n"

" return *this;\n"

" }\n"

" };\n"

"};\n");

ASSERT_EQUALS("[test.cpp:8]: (warning) 'operator=' should check for assignment to self\n", errout.str());

// this test has an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

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

" };\n"

"};\n"

"A::B & A::B::operator=(const A::B &b) { if (&b != this) { } return *this; }\n");

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

// this test doesn't have an assignment test but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

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

" };\n"

"};\n"

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

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

// this test needs an assignment test and has it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" char * s;\n"

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

" };\n"

"};\n"

"A::B & A::B::operator=(const A::B &b)\n"

"{\n"

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

" {\n"

" free(s);\n"

" s = strdup(b.s);\n"

" }\n"

" return *this;\n"

" }\n");

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

// this test needs an assignment test but doesn't have it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B\n"

" {\n"

" public:\n"

" char * s;\n"

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

" };\n"

"};\n"

"A::B & A::B::operator=(const A::B &b)\n"

"{\n"

" free(s);\n"

" s = strdup(b.s);\n"

" return *this;\n"

" }\n");

ASSERT_EQUALS("[test.cpp:11]: (warning) 'operator=' should check for assignment to self\n", errout.str());

}

void operatorEqToSelf3() {

// this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it

checkOpertorEqToSelf(

"class A : public B, public C\n"

"{\n"

"public:\n"

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

"};\n");

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

// this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it

checkOpertorEqToSelf(

"class A : public B, public C\n"

"{\n"

"public:\n"

" char *s;\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" return *this;\n"

" }\n"

"};\n");

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

// this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it

checkOpertorEqToSelf(

"class A : public B, public C\n"

"{\n"

"public:\n"

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

"};\n"

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

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

// this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it

checkOpertorEqToSelf(

"class A : public B, public C\n"

"{\n"

"public:\n"

" char *s;\n"

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

"};\n"

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

"{\n"

" free(s);\n"

" s = strdup(a.s);\n"

" return *this;\n"

"}\n");

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

}

void operatorEqToSelf4() {

// this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B : public C, public D\n"

" {\n"

" public:\n"

" B & operator=(const B &b) { return *this; }\n"

" };\n"

"};\n");

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

// this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B : public C, public D\n"

" {\n"

" public:\n"

" char * s;\n"

" B & operator=(const B &b)\n"

" {\n"

" free(s);\n"

" s = strdup(b.s);\n"

" return *this;\n"

" }\n"

" };\n"

"};\n");

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

// this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B : public C, public D\n"

" {\n"

" public:\n"

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

" };\n"

"};\n"

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

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

// this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" class B : public C, public D\n"

" {\n"

" public:\n"

" char * s;\n"

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

" };\n"

"};\n"

"A::B & A::B::operator=(const A::B &b)\n"

"{\n"

" free(s);\n"

" s = strdup(b.s);\n"

" return *this;\n"

"}\n");

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

}

void operatorEqToSelf5() {

// ticket # 1233

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

" {\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" }\n"

" return *this;\n"

" }\n"

"};");

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

checkOpertorEqToSelf(

"class A\n"

"{\n"

"public:\n"

" char *s;\n"

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

" {\n"

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

" {\n"

" free(s);\n"

" s = strdup(a.s);\n"

" }\n"

" return *this;\n"

" }\n"

"};");

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