TestStl() : TestFixture("TestStl") {

}

void run() {

TEST_CASE(iterator1);

TEST_CASE(iterator2);

TEST_CASE(iterator3);

TEST_CASE(iterator4);

TEST_CASE(iterator5);

TEST_CASE(iterator6);

TEST_CASE(iterator7);

TEST_CASE(iterator8);

TEST_CASE(iterator9);

TEST_CASE(iterator10);

TEST_CASE(iterator11);

TEST_CASE(iterator12);

TEST_CASE(iterator13);

TEST_CASE(iterator14); // #5598 invalid code causing a crash

TEST_CASE(dereference);

TEST_CASE(dereference_break); // #3644 - handle "break"

TEST_CASE(dereference_member);

TEST_CASE(STLSize);

TEST_CASE(STLSizeNoErr);

TEST_CASE(erase1);

TEST_CASE(erase2);

TEST_CASE(erase3);

TEST_CASE(erase4);

TEST_CASE(erase5);

TEST_CASE(erase6);

TEST_CASE(eraseBreak);

TEST_CASE(eraseContinue);

TEST_CASE(eraseReturn1);

TEST_CASE(eraseReturn2);

TEST_CASE(eraseReturn3);

TEST_CASE(eraseGoto);

TEST_CASE(eraseAssign1);

TEST_CASE(eraseAssign2);

TEST_CASE(eraseAssign3);

TEST_CASE(eraseAssign4);

TEST_CASE(eraseAssignByFunctionCall);

TEST_CASE(eraseErase);

TEST_CASE(eraseByValue);

TEST_CASE(eraseOnVector);

TEST_CASE(pushback1);

TEST_CASE(pushback2);

TEST_CASE(pushback3);

TEST_CASE(pushback4);

TEST_CASE(pushback5);

TEST_CASE(pushback6);

TEST_CASE(pushback7);

TEST_CASE(pushback8);

TEST_CASE(pushback9);

TEST_CASE(pushback10);

TEST_CASE(pushback11);

TEST_CASE(pushback12);

TEST_CASE(insert1);

TEST_CASE(insert2);

TEST_CASE(stlBoundaries1);

TEST_CASE(stlBoundaries2);

TEST_CASE(stlBoundaries3);

TEST_CASE(stlBoundaries4); // #4364

TEST_CASE(stlBoundaries5); // #4352

// if (str.find("ab"))

TEST_CASE(if_find);

TEST_CASE(if_str_find);

TEST_CASE(size1);

TEST_CASE(size2);

TEST_CASE(size3);

TEST_CASE(size4); // #2652 - don't warn about vector/deque

// Redundant conditions..

// if (ints.find(123) != ints.end()) ints.remove(123);

TEST_CASE(redundantCondition1);

// missing inner comparison when incrementing iterator inside loop

TEST_CASE(missingInnerComparison1);

TEST_CASE(missingInnerComparison2); // no FP when there is comparison

TEST_CASE(missingInnerComparison3); // no FP when there is iterator shadowing

TEST_CASE(missingInnerComparison4); // no FP when "break;" is used

TEST_CASE(missingInnerComparison5); // Ticket #2154 - FP

TEST_CASE(missingInnerComparison6); // #2643 - 'it=foo.insert(++it,0);'

// catch common problems when using the string::c_str() function

TEST_CASE(cstr);

TEST_CASE(autoPointer);

TEST_CASE(uselessCalls);

TEST_CASE(stabilityOfChecks); // #4684 cppcheck crash in template function call

TEST_CASE(dereferenceInvalidIterator);

TEST_CASE(dereference_auto);

TEST_CASE(readingEmptyStlContainer);

}

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

// Clear the error buffer..

errout.str("");

Settings settings;

settings.addEnabled("warning");

settings.addEnabled("style");

settings.addEnabled("performance");

settings.inconclusive = inconclusive;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList2();

// Check..

CheckStl checkStl;

checkStl.runSimplifiedChecks(&tokenizer, &settings, this);

}

void check(const std::string &code, const bool inconclusive=false) {

check(code.c_str(), inconclusive);

}

void iterator1() {

check("void f()\n"

"{\n"

" list<int> l1;\n"

" list<int> l2;\n"

" for (list<int>::iterator it = l1.begin(); it != l2.end(); ++it)\n"

" { }\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());

// Same check with reverse iterator

check("void f()\n"

"{\n"

" list<int> l1;\n"

" list<int> l2;\n"

" for (list<int>::const_reverse_iterator it = l1.rbegin(); it != l2.rend(); ++it)\n"

" { }\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());

}

void iterator2() {

check("void foo()\n"

"{\n"

" list<int> l1;\n"

" list<int> l2;\n"

" list<int>::iterator it = l1.begin();\n"

" while (it != l2.end())\n"

" {\n"

" ++it;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());

}

void iterator3() {

check("void foo()\n"

"{\n"

" list<int> l1;\n"

" list<int> l2;\n"

" list<int>::iterator it = l1.begin();\n"

" l2.insert(it, 0);\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());

}

void iterator4() {

check("void foo(std::vector<std::string> &test)\n"

"{\n"

" std::set<int> result;\n"

" for (std::vector<std::string>::const_iterator cit = test.begin();\n"

" cit != test.end();\n"

" ++cit)\n"

" {\n"

" result.insert(cit->size());\n"

" }\n"

"}");

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

}

void iterator5() {

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::find(ints1.begin(), ints2.end(), 22);\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());

}

void iterator6() {

// Ticket #1357

check("void foo(const std::set<int> &ints1)\n"

"{\n"

" std::set<int> ints2;\n"

" std::set<int>::iterator it1 = ints1.begin();\n"

" std::set<int>::iterator it2 = ints1.end();\n"

" ints2.insert(it1, it2);\n"

"}");

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

check("void foo(const std::set<int> &ints1)\n"

"{\n"

" std::set<int> ints2;\n"

" std::set<int>::iterator it1 = ints1.begin();\n"

" std::set<int>::iterator it2 = ints2.end();\n"

" ints2.insert(it1, it2);\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterators of different containers are used together.\n", "", errout.str());

}

void iterator7() {

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints1.rbegin(), 5), ints2.end());\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints2.rbegin(), 5), ints1.end());\n"

"}");

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

}

void iterator8() {

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints2.end(), ints1.begin(), ints1.end());\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints1.end());\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::find_first_of(foo.bar.begin(), foo.bar.end()-6, ints2.begin(), ints1.end());\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());

check("void foo()\n"

"{\n"

" std::vector<int> ints1;\n"

" std::vector<int> ints2;\n"

" std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints2.end());\n"

"}");

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

}

void iterator9() {

// Ticket #1600

check("void foo(std::vector<int> &r)\n"

"{\n"

" std::vector<int>::iterator aI = r.begin();\n"

" while(aI != r.end())\n"

" {\n"

" if (*aI == 0)\n"

" {\n"

" r.insert(aI, 42);\n"

" return;\n"

" }\n"

" ++aI;\n"

" }\n"

"}");

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

// Ticket #2481

check("void foo(std::vector<int> &r)\n"

"{\n"

" std::vector<int>::iterator aI = r.begin();\n"

" while(aI != r.end())\n"

" {\n"

" if (*aI == 0)\n"

" {\n"

" r.insert(aI, 42);\n"

" break;\n"

" }\n"

" ++aI;\n"

" }\n"

"}");

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

// Execution path checking..

check("void foo(std::vector<int> &r, int c)\n"

"{\n"

" std::vector<int>::iterator aI = r.begin();\n"

" while(aI != r.end())\n"

" {\n"

" if (*aI == 0)\n"

" {\n"

" r.insert(aI, 42);\n"

" if (c)\n"

" {\n"

" return;\n"

" }\n"

" }\n"

" ++aI;\n"

" }\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:14] (error) After insert(), the iterator 'aI' may be invalid.", "", errout.str());

}

void iterator10() {

// Ticket #1679

check("void foo()\n"

"{\n"

" std::set<int> s1;\n"

" std::set<int> s2;\n"

" for (std::set<int>::iterator it = s1.begin(); it != s1.end(); ++it)\n"

" {\n"

" if (true) { }\n"

" if (it != s2.end()) continue;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:8]: (error) Same iterator is used with different containers 's1' and 's2'.\n", errout.str());

}

void iterator11() {

// Ticket #3433

check("int main() {\n"

" map<int, int> myMap;\n"

" vector<string> myVector;\n"

" for(vector<int>::iterator x = myVector.begin(); x != myVector.end(); x++)\n"

" myMap.erase(*x);\n"

"}");

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

}

void iterator12() {

// Ticket #3201

check("void f() {\n"

" std::map<int, int> map1;\n"

" std::map<int, int> map2;\n"

" std::map<int, int>::const_iterator it = map1.find(123);\n"

" if (it == map2.end()) { }"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Same iterator is used with different containers 'map1' and 'map2'.\n", errout.str());

check("void f(std::string &s) {\n"

" int pos = s.find(x);\n"

" s.erase(pos);\n"

" s.erase(pos);\n"

"}");

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

}

void iterator13() {

check("void f() {\n"

" std::vector<int> a;\n"

" std::vector<int> t;\n"

" std::vector<int>::const_iterator it;\n"

" it = a.begin();\n"

" while (it!=a.end())\n"

" v++it;\n"

" it = t.begin();\n"

" while (it!=a.end())\n"

" ++it;\n"

"}");

ASSERT_EQUALS("[test.cpp:9]: (error) Same iterator is used with different containers 't' and 'a'.\n", errout.str());

// #4062

check("void f() {\n"

" std::vector<int> a;\n"

" std::vector<int> t;\n"

" std::vector<int>::const_iterator it;\n"

" it = a.begin();\n"

" while (it!=a.end())\n"

" v++it;\n"

" it = t.begin();\n"

" while (it!=t.end())\n"

" ++it;\n"

"}");

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

check("void f() {\n"

" std::vector<int> a;\n"

" std::vector<int> t;\n"

" std::vector<int>::const_iterator it;\n"

" if(z)\n"

" it = a.begin();\n"

" else\n"

" it = t.begin();\n"

" while (z && it!=a.end())\n"

" v++it;\n"

" while (!z && it!=t.end())\n"

" v++it;\n"

"}");

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

}

void iterator14() {

check(" { { void foo() { struct }; template <typename> struct S { Used x; void bar() } auto f = [this] { }; } };");

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

}

// Dereferencing invalid pointer

void dereference() {

check("void f()\n"

"{\n"

" std::vector<int> ints;\n"

" std::vector<int>::iterator iter;\n"

" iter = ints.begin() + 2;\n"

" ints.erase(iter);\n"

" std::cout << (*iter) << std::endl;\n"

"}");

ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());

}

void dereference_break() { // #3644

check("void f(std::vector<int> &ints) {\n"

" std::vector<int>::iterator iter;\n"

" for (iter=ints.begin();iter!=ints.end();++iter) {\n"

" if (*iter == 2) {\n"

" ints.erase(iter);\n"

" break;\n"

" }\n"

" if (*iter == 3) {\n"

" ints.erase(iter);\n"

" break;\n"

" }\n"

" }\n"

"}");

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

}

void dereference_member() {

check("void f()\n"

"{\n"

" std::map<int, int> ints;\n"

" std::map<int, int>::iterator iter;\n"

" iter = ints.begin();\n"

" ints.erase(iter);\n"

" std::cout << iter->first << std::endl;\n"

"}");

ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());

// Reverse iterator

check("void f()\n"

"{\n"

" std::map<int, int> ints;\n"

" std::map<int, int>::reverse_iterator iter;\n"

" iter = ints.rbegin();\n"

" ints.erase(iter);\n"

" std::cout << iter->first << std::endl;\n"

"}");

ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());

}

void dereference_auto() {

check("void f()\n"

"{\n"

" std::vector<int> ints;\n"

" auto iter = ints.begin() + 2;\n"

" ints.erase(iter);\n"

" std::cout << (*iter) << std::endl;\n"

"}");

ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:5]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());

check("void f() {\n"

" auto x = *myList.begin();\n"

" myList.erase(x);\n"

" auto b = x.first;\n"

"}");

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

}

void STLSize() {

check("void foo()\n"

"{\n"

" std::vector<int> foo;\n"

" for (unsigned int ii = 0; ii <= foo.size(); ++ii)\n"

" {\n"

" foo[ii] = 0;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());

check("void foo(std::vector<int> foo) {\n"

" for (unsigned int ii = 0; ii <= foo.size(); ++ii) {\n"

" foo.at(ii) = 0;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo.at(ii) is out of bounds.\n", errout.str());

check("void foo(const std::string& foo) {\n"

" for (unsigned int ii = 0; ii <= foo.length(); ++ii) {\n"

" foo[ii] = 'x';\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());

check("void foo(const std::string& foo, unsigned int ii) {\n"

" if (ii <= foo.length()) {\n"

" foo[ii] = 'x';\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());

check("void foo(const std::string& foo, unsigned int ii) {\n"

" if (anything()) {\n"

" } else if (ii <= foo.length()) {\n"

" foo[ii] = 'x';\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());

check("void foo()\n"

"{\n"

" std::vector<int> foo;\n"

" foo.push_back(1);\n"

" for (unsigned int ii = 0; ii <= foo.size(); ++ii)\n"

" {\n"

" }\n"

" int ii = 0;\n"

" foo[ii] = 0;\n"

"}");

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

}

void STLSizeNoErr() {

{

check("void foo()\n"

"{\n"

" std::vector<int> foo;\n"

" for (unsigned int ii = 0; ii < foo.size(); ++ii)\n"

" {\n"

" foo[ii] = 0;\n"

" }\n"

"}");

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

}

{

check("void foo()\n"

"{\n"

" std::vector<int> foo;\n"

" for (unsigned int ii = 0; ii <= foo.size(); ++ii)\n"

" {\n"

" }\n"

"}");

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

}

{

check("void foo()\n"

"{\n"

" std::vector<int> foo;\n"

" for (unsigned int ii = 0; ii <= foo.size(); ++ii)\n"

" {\n"

" if (ii == foo.size())\n"

" {\n"

" }\n"

" else\n"

" {\n"

" foo[ii] = 0;\n"

" }\n"

" }\n"

"}");

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

}

{

check("void f(const std::map<int,int> &data) {\n"

" int i = x;"

" for (int i = 5; i <= data.size(); i++)\n"

" data[i] = 0;\n"

"}");

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

}

}

void erase1() {

check("void f()\n"

"{\n"

" for (it = foo.begin(); it != foo.end(); ++it) {\n"

" foo.erase(it);\n"

" }\n"

" for (it = foo.begin(); it != foo.end(); ++it) {\n"

" foo.erase(it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Iterator 'it' used after element has been erased.\n"

"[test.cpp:6] -> [test.cpp:7]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f(std::list<int> &ints)\n"

"{\n"

" std::list<int>::iterator i = ints.begin();\n"

" i = ints.erase(i);\n"

" *i = 0;\n"

"}");

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

// #2101

check("void f(vector< list<int> > &ints, unsigned int i)\n"

"{\n"

" list<int>::iterator it;\n"

" for(it = ints[i].begin(); it != ints[i].end(); it++) {\n"

" if (*it % 2)\n"

" it = ints[i].erase(it);\n"

" }\n"

"}");

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

}

void erase2() {

check("static void f()\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); it = next)\n"

" {\n"

" next = it;\n"

" next++;\n"

" foo.erase(it);\n"

" }\n"

"}");

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

}

void erase3() {

check("static void f(std::list<abc> &foo)\n"

"{\n"

" std::list<abc>::iterator it = foo.begin();\n"

" foo.erase(it->a);\n"

" if (it->b);\n"

"}");

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

}

void erase4() {

check("void f()\n"

"{\n"

" std::list<int>::iterator it, it2;\n"

" for (it = foo.begin(); it != i2; ++it)\n"

" {\n"

" foo.erase(it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f()\n"

"{\n"

" std::list<int>::iterator it = foo.begin();\n"

" for (; it != i2; ++it)\n"

" {\n"

" foo.erase(it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f()\n"

"{\n"

" std::list<int>::iterator it = foo.begin();\n"

" while (it != i2)\n"

" {\n"

" foo.erase(it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f()\n"

"{\n"

" std::list<int>::iterator it = foo.begin();\n"

" while (it != i2)\n"

" {\n"

" foo.erase(++it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

}

void erase5() {

check("void f()\n"

"{\n"

" std::list<int> foo;\n"

" std::list<int>::iterator it;\n"

" for (it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" if (*it == 123)\n"

" foo.erase(it);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:8]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

}

void erase6() {

check("void f() {\n"

" std::vector<int> vec(3);\n"

" std::vector<int>::iterator it;\n"

" std::vector<int>::iterator itEnd = vec.end();\n"

" for (it = vec.begin(); it != itEnd; it = vec.begin(), itEnd = vec.end())\n"

" {\n"

" vec.erase(it);\n"

" }\n"

"}");

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

}

void eraseBreak() {

check("void f()\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(it);\n"

" if (x)"

" break;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f()\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" if (x) {\n"

" foo.erase(it);\n"

" break;\n"

" }\n"

" }\n"

"}");

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

check("void f(int x)\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(it);\n"

" if (x)"

" return;\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

}

void eraseContinue() {

check("void f(std::vector<int> &ints)\n"

"{\n"

" std::vector<int>::iterator it;\n"

" std::vector<int>::iterator jt = ints.begin();\n"

" for (it = ints.begin(); it != ints.end(); it = jt) {\n"

" ++jt;\n"

" if (*it == 1) {\n"

" jt = ints.erase(it);\n"

" continue;\n"

" }\n"

" }\n"

"}");

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

}

void eraseReturn1() {

check("void f()\n"

"{\n"

" std::vector<int> foo;\n"

" std::vector<int>::iterator it;\n"

" for (it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(it);\n"

" return;\n"

" }\n"

"}");

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

}

void eraseReturn2() {

check("void f()\n"

"{\n"

" std::vector<int> foo;\n"

" std::vector<int>::iterator it;\n"

" for (it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" if (*it == 1) {\n"

" foo.erase(it);\n"

" return;\n"

" }\n"

" else {\n"

" foo.erase(it);\n"

" return;\n"

" }\n"

" }\n"

"}");

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

}

void eraseReturn3() {

check("void f()\n"

"{\n"

" std::vector<int> foo;\n"

" std::vector<int>::iterator it;\n"

" for (it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" if (somecondition) {\n"

" if (*it == 1)\n"

" foo.erase(it);\n"

" else\n"

" *it = 0;\n"

" return;\n"

" }\n"

" }\n"

"}");

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

check("void f()\n"

"{\n"

" std::vector<int> foo;\n"

" std::vector<int>::iterator it;\n"

" for (it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" if (a) {\n"

" if (b)\n"

" foo.erase(it);\n"

" else\n"

" *it = 0;\n"

" }\n"

" }\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Dangerous iterator usage after erase()-method.\n", "", errout.str());

}

void eraseGoto() {

check("void f()\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(it);\n"

" goto abc;\n"

" }\n"

"bar:\n"

"}");

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

}

void eraseAssign1() {

check("void f()\n"

"{\n"

" for (iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(it);\n"

" it = foo.begin();\n"

" }\n"

"}");

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

}

void eraseAssign2() {

check("void f(list<int> &ints)\n"

"{\n"

" for (list<int>::iterator it = ints.begin(); it != ints.end();) {\n"

" if (*it == 123) {\n"

" list<int>::iterator copy = it;\n"

" ++copy;\n"

" ints.erase(it);\n"

" it = copy;\n"

" } else {\n"

" it->second = 123;\n"

" ++it;\n"

" }\n"

" }\n"

"}");

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

}

void eraseAssign3() {

check("void f(std::list<list<int> >& l) {\n"

" std::list<std::list<int> >::const_iterator i = l.begin();\n"

" std::list<int>::const_iterator j = (*i).begin();\n"

" cout << *j << endl;\n"

"}");

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

}

void eraseAssign4() {

check("void f(std::list<int> data) {\n"

" std::list<int>::const_iterator it = data.begin();\n"

" it = data.erase(it);\n"

" it = data.erase(it);\n"

"}");

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

check("void f(Data data) {\n"

" std::list<int>::const_iterator it = data.ints.begin();\n"

" it = data.ints.erase(it);\n"

" it = data.ints.erase(it);\n"

"}");

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

}

void eraseAssignByFunctionCall() {

check("void f(std::list<list<int> >& l) {\n"

" std::list<foo>::const_iterator i;\n"

" bar(i);\n"

" cout << *i;\n"

"}");

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

}

void eraseErase() {

check("void f(std::vector<ints> &ints)\n"

"{\n"

" std::vector<int>::iterator iter;\n"

" iter = ints.begin() + 2;\n"

" ints.erase(iter);\n"

" ints.erase(iter);\n"

"}");

ASSERT_EQUALS("[test.cpp:6]: (error) Invalid iterator: iter\n", errout.str());

}

void eraseByValue() {

check("void f()\n"

"{\n"

" std::set<int> foo;\n"

" for (std::set<int>::iterator it = foo.begin(); it != foo.end(); ++it)\n"

" {\n"

" foo.erase(*it);\n"

" }\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterator 'it' becomes invalid when deleted by value from 'foo'\n", "", errout.str());

check("int f(std::set<int> foo) {\n"

" std::set<int>::iterator it = foo.begin();\n"

" foo.erase(*it);\n"

" return *it;\n"

"}");

ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (error) Iterator 'it' used after element has been erased.\n", errout.str());

check("void f()\n"

"{\n"

" std::set<int> foo;\n"

" std::set<int>::iterator it = foo.begin();\n"

" foo.erase(*it);\n"

"}");

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

// #5669

check("void f() {\n"

" HashSet_Ref::iterator aIt = m_ImplementationMap.find( xEle );\n"

" m_SetLoadedFactories.erase(*aIt);\n"

" m_SetLoadedFactories.erase(aIt);\n"

"}");

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

check("void f(const std::list<int>& m_ImplementationMap) {\n"

" std::list<int>::iterator aIt = m_ImplementationMap.find( xEle );\n"

" m_ImplementationMap.erase(*aIt);\n"

" m_ImplementationMap.erase(aIt);\n"

"}");