TestStl() : TestFixture("TestStl") {

}

Settings settings;

void run() override {

settings.addEnabled("warning");

settings.addEnabled("style");

settings.addEnabled("performance");

LOAD_LIB_2(settings.library, "std.cfg");

TEST_CASE(outOfBounds);

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); // #8191

TEST_CASE(iteratorExpression);

TEST_CASE(iteratorSameExpression);

TEST_CASE(dereference);

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

TEST_CASE(dereference_member);

TEST_CASE(STLSize);

TEST_CASE(STLSizeNoErr);

TEST_CASE(negativeIndex);

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

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

TEST_CASE(insert1);

TEST_CASE(insert2);

TEST_CASE(stlBoundaries1);

TEST_CASE(stlBoundaries2);

TEST_CASE(stlBoundaries3);

TEST_CASE(stlBoundaries4); // #4364

TEST_CASE(stlBoundaries5); // #4352

TEST_CASE(stlBoundaries6); // #7106

// 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(dereferenceInvalidIterator2); // #6572

TEST_CASE(dereference_auto);

TEST_CASE(readingEmptyStlContainer);

}

void check(const char code[], const bool inconclusive=false, const Standards::cppstd_t cppstandard=Standards::CPP11) {

// Clear the error buffer..

errout.str("");

settings.inconclusive = inconclusive;

settings.standards.cpp = cppstandard;

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

tokenizer.simplifyTokenList2();

// Check..

CheckStl checkStl(&tokenizer, &settings, this);

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

}

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

check(code.c_str(), inconclusive);

}

void checkNormal(const char code[]) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

// Check..

CheckStl checkStl(&tokenizer, &settings, this);

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

}

void outOfBounds() {

setMultiline();

checkNormal("void f(std::vector<int> v) {\n"

" v.front();\n"

" if (v.empty()) {}\n"

"}\n");

ASSERT_EQUALS("test.cpp:2:warning:Accessing an item in container 'v'. Either the condition 'v.empty()' is redundant or 'v' can be empty.\n"

"test.cpp:3:note:condition 'v.empty()'\n"

"test.cpp:2:note:Access out of bounds\n", errout.str());

checkNormal("void f(std::vector<int> v) {\n"

" if (v.size() == 3) {}\n"

" v[16] = 0;\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:warning:Possible access out of bounds of container 'v'; size=3, index=16\n"

"test.cpp:2:note:condition 'v.size()==3'\n"

"test.cpp:3:note:Access out of bounds\n", errout.str());

checkNormal("void f(std::vector<int> v) {\n"

" int i = 16;\n"

" if (v.size() == 3) {\n"

" v[i] = 0;\n"

" }\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:warning:Possible access out of bounds of container 'v'; size=3, index=16\n"

"test.cpp:3:note:condition 'v.size()==3'\n"

"test.cpp:4:note:Access out of bounds\n", errout.str());

checkNormal("void f(std::vector<int> v, int i) {\n"

" if (v.size() == 3 || i == 16) {}\n"

" v[i] = 0;\n"

"}\n");

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

checkNormal("void f(std::map<int,int> x) {\n"

" if (x.empty()) { x[1] = 2; }\n"

"}\n");

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

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

" if (s.size() == 1) {\n"

" s[2] = 0;\n"

" }\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:warning:Possible access out of bounds of container 's'; size=1, index=2\n"

"test.cpp:2:note:condition 's.size()==1'\n"

"test.cpp:3:note:Access out of bounds\n", errout.str());

}

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

check("void f()\n"

"{\n"

" list<int> l1;\n"

" list<int> l2;\n"

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

" { }\n"

"}");

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

check("struct C { std::list<int> l1; void func(); };\n"

"void C::func() {\n"

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

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

" C c;\n"

" for (it = c.l1.begin(); it != c.l1.end(); ++it) { }\n"

"}");

ASSERT_EQUALS("", 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());

check("void foo() {\n" // #5803

" list<int> l1;\n"

" list<int> l2;\n"

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

" l2.insert(it, l1.end());\n"

"}");

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

check("void foo() {\n" // #7658

" list<int> l1;\n"

" list<int> l2;\n"

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

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

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

"}");

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

// only warn for insert when there are preciself 2 arguments.

check("void foo() {\n"

" list<int> l1;\n"

" list<int> l2;\n"

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

" l2.insert(it);\n"

"}");

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

check("void foo() {\n"

" list<int> l1;\n"

" list<int> l2;\n"

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

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

"}");

ASSERT_EQUALS("", 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());

// #6839

check("void f(const std::wstring& a, const std::wstring& b) {\n"

" const std::string tp1 = std::string(a.begin(), b.end());\n"

" const std::wstring tp2 = std::string(b.begin(), a.end());\n"

" const std::u16string tp3(a.begin(), b.end());\n"

" const std::u32string tp4(b.begin(), a.end());\n"

" const std::string fp1 = std::string(a.begin(), a.end());\n"

" const std::string tp2(a.begin(), a.end());\n"

"}");

ASSERT_EQUALS(// TODO "[test.cpp:2]: (error) Iterators of different containers are used together.\n"

// TODO "[test.cpp:3]: (error) Iterators of different containers are used together.\n"

"[test.cpp:4]: (error) Iterators of different containers are used together.\n"

"[test.cpp:5]: (error) Iterators of different containers are used together.\n", 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() {\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 (map2.end() == it) { }"

"}");

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"

" ++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 f() {\n"

" std::map<int,Foo> x;\n"

" std::map<int,Foo>::const_iterator it;\n"

" for (it = x.find(0)->second.begin(); it != x.find(0)->second.end(); ++it) {}\n"

"}");

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

}

void iteratorExpression() {

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

"std::vector<int>& g();\n"

"void foo() {\n"

" (void)std::find(f().begin(), g().end(), 0);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());

check("struct A {\n"

" std::vector<int>& f();\n"

" std::vector<int>& g();\n"

"};\n"

"void foo() {\n"

" (void)std::find(A().f().begin(), A().g().end(), 0);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:6]: (warning) Iterators to containers from different expressions 'A().f()' and 'A().g()' are used together.\n", errout.str());

check("struct A {\n"

" std::vector<int>& f();\n"

" std::vector<int>& g();\n"

"};\n"

"void foo() {\n"

" (void)std::find(A{}.f().begin(), A{}.g().end(), 0);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:6]: (warning) Iterators to containers from different expressions 'A{}.f()' and 'A{}.g()' are used together.\n", errout.str());

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

"std::vector<int>& g();\n"

"void foo() {\n"

" (void)std::find(begin(f()), end(g()), 0);\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());

check("struct A {\n"

" std::vector<int>& f();\n"

" std::vector<int>& g();\n"

"};\n"

"void foo() {\n"

" (void)std::find(A().f().begin(), A().f().end(), 0);\n"

"}\n");

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

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

"std::vector<int>& g();\n"

"void foo() {\n"

" auto it = f().end();"

" (void)std::find(f().begin(), it, 0);\n"

" (void)std::find(f().begin(), it + 1, 0);\n"

" (void)std::find(f().begin() + 1, it + 1, 0);\n"

" (void)std::find(f().begin() + 1, it, 0);\n"

" (void)std::find(f().begin(), f().end(), 0);\n"

" (void)std::find(f().begin() + 1, f().end(), 0);\n"

" (void)std::find(f().begin(), f().end() - 1, 0);\n"

" (void)std::find(f().begin() + 1, f().end() - 1, 0);\n"

" (void)std::find(begin(f()), end(f()));\n"

" (void)std::find(begin(f()) + 1, end(f()), 0);\n"

" (void)std::find(begin(f()), end(f()) - 1, 0);\n"

" (void)std::find(begin(f()) + 1, end(f()) - 1, 0);\n"

"}\n");

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

}

void iteratorSameExpression() {

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

" std::for_each(v.begin(), v.begin(), [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", errout.str());

check("std::vector<int>& g();\n"

"void f() {\n"

" std::for_each(g().begin(), g().begin(), [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());

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

" std::for_each(v.end(), v.end(), [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", errout.str());

check("std::vector<int>& g();\n"

"void f() {\n"

" std::for_each(g().end(), g().end(), [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());

check("std::vector<int>::iterator g();\n"

"void f(std::vector<int> v) {\n"

" std::for_each(g(), g(), [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());

check("void f(std::vector<int>::iterator it) {\n"

" std::for_each(it, it, [](int){});\n"

"}\n");

ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", 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());

// #6554 "False positive eraseDereference - erase in while() loop"

check("typedef std::map<Packet> packetMap;\n"

"packetMap waitingPackets;\n"

"void ProcessRawPacket() {\n"

" packetMap::iterator wpi;\n"

" while ((wpi = waitingPackets.find(lastInOrder + 1)) != waitingPackets.end()) {\n"

" waitingPackets.erase(wpi);\n"

" for (unsigned pos = 0; pos < buf.size(); ) { }\n"

" }\n"

"}");

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

// #8509 Uniform initialization ignored for iterator

check("void f() {\n"

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

" std::vector<int>::const_iterator iter {ints.cbegin()};\n"

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

"}");

ASSERT_EQUALS("", 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());

check("const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {\n"

" if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {\n"

" auto From = TD->getInstantiatedFrom();\n"

" }\n"

" return nullptr;\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"

" do {\n"

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

" ++i;\n"

" } while(ii <= foo.length());\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());

check("void foo() {\n"

" for (B b : D()) {}\n" // Don't crash on range-based for-loop

"}");

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 negativeIndex() {

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

" v[-11] = 123;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (error) Array index -11 is out of bounds.\n", errout.str());

}

void erase1() {

check("void f()\n"

"{\n"

" std::list<int>::iterator it;\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:4] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n"

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

check("void f()\n"

"{\n"

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

" while (i != x.y.end())\n"

" i = x.y.erase(i);\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());