/*

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

* Copyright (C) 2007-2023 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "checkstl.h"

#include "errortypes.h"

#include "settings.h"

#include "standards.h"

#include "fixture.h"

#include "tokenize.h"

#include "utils.h"

#include <cstddef>

#include <list>

#include <sstream> // IWYU pragma: keep

#include <string>

class TestStl : public TestFixture {

public:

TestStl() : TestFixture("TestStl") {}

private:

Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).severity(Severity::performance).library("std.cfg").build();

void run() override {

TEST_CASE(outOfBounds);

TEST_CASE(outOfBoundsSymbolic);

TEST_CASE(outOfBoundsIndexExpression);

TEST_CASE(outOfBoundsIterator);

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(iterator15); // #8341

TEST_CASE(iterator16);

TEST_CASE(iterator17);

TEST_CASE(iterator18);

TEST_CASE(iterator19);

TEST_CASE(iterator20);

TEST_CASE(iterator21);

TEST_CASE(iterator22);

TEST_CASE(iterator23);

TEST_CASE(iterator24);

TEST_CASE(iterator25); // #9742

TEST_CASE(iterator26); // #9176

TEST_CASE(iterator27); // #10378

TEST_CASE(iterator28); // #10450

TEST_CASE(iteratorExpression);

TEST_CASE(iteratorSameExpression);

TEST_CASE(mismatchingContainerIterator);

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

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

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

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

TEST_CASE(dereferenceInvalidIterator);

TEST_CASE(dereferenceInvalidIterator2); // #6572

TEST_CASE(dereference_auto);

TEST_CASE(loopAlgoElementAssign);

TEST_CASE(loopAlgoAccumulateAssign);

TEST_CASE(loopAlgoContainerInsert);

TEST_CASE(loopAlgoIncrement);

TEST_CASE(loopAlgoConditional);

TEST_CASE(loopAlgoMinMax);

TEST_CASE(loopAlgoMultipleReturn);

TEST_CASE(invalidContainer);

TEST_CASE(invalidContainerLoop);

TEST_CASE(findInsert);

TEST_CASE(checkKnownEmptyContainer);

TEST_CASE(checkMutexes);

}

#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)

void check_(const char* file, int line, const char code[], const bool inconclusive = false, const Standards::cppstd_t cppstandard = Standards::CPPLatest) {

// Clear the error buffer..

errout.str("");

const Settings settings1 = settingsBuilder(settings).certainty(Certainty::inconclusive, inconclusive).cpp(cppstandard).build();

// Tokenize..

Tokenizer tokenizer(&settings1, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, "test.cpp"), file, line);

runChecks<CheckStl>(&tokenizer, &settings1, this);

}

void check_(const char* file, int line, const std::string& code, const bool inconclusive = false) {

check_(file, line, code.c_str(), inconclusive);

}

#define checkNormal(code) checkNormal_(code, __FILE__, __LINE__)

void checkNormal_(const char code[], const char* file, int line) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, "test.cpp"), file, line);

// Check..

runChecks<CheckStl>(&tokenizer, &settings, this);

}

void outOfBounds() {

setMultiline();

checkNormal("bool f(const int a, const int b)\n" // #8648

"{\n"

" std::cout << a << b;\n"

" return true;\n"

"}\n"

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

"{\n"

" if(v.size() >=2 &&\n"

" bar(v[2], v[3]) )\n" // v[3] is accessed

" {;}\n"

"}\n");

ASSERT_EQUALS("test.cpp:9:warning:Either the condition 'v.size()>=2' is redundant or v size can be 2. Expression 'v[2]' cause access out of bounds.\n"

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

"test.cpp:9:note:Access out of bounds\n"

"test.cpp:9:warning:Either the condition 'v.size()>=2' is redundant or v size can be 2. Expression 'v[3]' cause access out of bounds.\n"

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

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

checkNormal("void f() {\n"

" std::string s;\n"

" s[10] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's[10]' because 's' is empty.\n", errout.str());

checkNormal("void f() {\n"

" std::string s = \"abcd\";\n"

" s[10] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 's[10]', if 's' size is 4 and '10' is 10\n", errout.str());

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

" v.front();\n"

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

"}");

ASSERT_EQUALS("test.cpp:2:warning:Either the condition 'v.empty()' is redundant or expression 'v.front()' cause access out of bounds.\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"

"}");

ASSERT_EQUALS("test.cpp:3:warning:Either the condition 'v.size()==3' is redundant or v size can be 3. Expression 'v[16]' cause access out of bounds.\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"

"}");

ASSERT_EQUALS("test.cpp:4:warning:Either the condition 'v.size()==3' is redundant or v size can be 3. Expression 'v[i]' cause access out of bounds.\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"

"}");

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

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

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

"}");

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

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

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

" s[2] = 0;\n"

" }\n"

"}");

ASSERT_EQUALS("test.cpp:3:warning:Either the condition 's.size()==1' is redundant or s size can be 1. Expression 's[2]' cause access out of bounds.\n"

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

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

// Do not crash

checkNormal("void a() {\n"

" std::string b[];\n"

" for (auto c : b)\n"

" c.data();\n"

"}");

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

checkNormal("std::string f(std::string x) {\n"

" if (x.empty()) return {};\n"

" x[0];\n"

"}");

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

checkNormal("std::string f(std::string x) {\n"

" if (x.empty()) return std::string{};\n"

" x[0];\n"

"}");

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

checkNormal("void f() {\n"

" std::string s;\n"

" x = s.begin() + 1;\n"

"}");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's.begin()+1' because 's' is empty.\n", errout.str());

checkNormal("void f(int x) {\n"

" std::string s;\n"

" x = s.begin() + x;\n"

"}");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's.begin()+x' because 's' is empty and 'x' may be non-zero.\n", errout.str());

checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[42]; }\n"

"wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[42]; }");

ASSERT_EQUALS("test.cpp:1:error:Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42\n"

"test.cpp:2:error:Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42\n", errout.str());

checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[1]; }\n"

"wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[1]; }");

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

checkNormal("int f() {\n"

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

" std::vector<int> * pv = &v;\n"

" return (*pv)[42];\n"

"}");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in expression '(*pv)[42]' because '*pv' is empty.\n", errout.str());

checkNormal("void f() {\n"

" std::string s;\n"

" ++abc[s];\n"

"}");

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

// # 9274

checkNormal("char f(bool b) {\n"

" const std::string s = \"<a><b>\";\n"

" int x = 6;\n"

" if(b) ++x;\n"

" return s[x];\n"

"}");

ASSERT_EQUALS("test.cpp:5:error:Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 6\n", errout.str());

checkNormal("void f() {\n"

" static const int N = 4;\n"

" std::array<int, N> x;\n"

" x[0] = 0;\n"

"}");

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

checkNormal("void f(bool b) {\n"

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

" if (b)\n"

" x.push_back(1);\n"

" if (x.size() < 2)\n"

" return;\n"

" x[0] = 2;\n"

"}\n");

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

checkNormal("void f(bool b) {\n"

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

" if(v.at(b?42:0)) {}\n"

"}\n");

ASSERT_EQUALS(

"test.cpp:3:error:Out of bounds access in expression 'v.at(b?42:0)' because 'v' is empty and 'b?42:0' may be non-zero.\n",

errout.str());

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

" if (v.size() == 1)\n"

" if(v.at(b?42:0)) {}\n"

"}\n");

ASSERT_EQUALS(

"test.cpp:3:warning:Either the condition 'v.size()==1' is redundant or v size can be 1. Expression 'v.at(b?42:0)' cause access out of bounds.\n"

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

"test.cpp:3:note:Access out of bounds\n",

errout.str());

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

" T t;\n"

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s = { { &ArrS } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n", true);

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

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

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

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s = { { { &ArrS } } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n",

true);

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

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

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

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s = { { { { &ArrS } } } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n",

true);

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

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

" T t;\n"

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s { { &ArrS } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n",

true);

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

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

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

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s { { { &ArrS } } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n",

true);

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

check("struct T {\n"

" std::vector<int>* v;\n"

"};\n"

"struct S {\n"

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

"};\n"

"long g(S& s);\n"

"int f() {\n"

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

" S s { { { { &ArrS } } } };\n"

" g(s);\n"

" return ArrS[0];\n"

"}\n",

true);

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

checkNormal("extern void Bar(const double, const double);\n"

"void f(std::vector<double> &r, const double ) {\n"

" std::vector<double> result;\n"

" double d = 0.0;\n"

" const double inc = 0.1;\n"

" for(unsigned int i = 0; i < 10; ++i) {\n"

" result.push_back(d);\n"

" d = (i + 1) * inc;\n"

" }\n"

" Bar(1.0, d);\n"

" Bar(10U, result.size());\n"

" Bar(0.0, result[0]);\n"

" Bar(0.34, result[1]);\n"

"}\n");

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

checkNormal("void f(size_t entries) {\n"

" std::vector<uint8_t> v;\n"

" if (v.size() < entries + 2)\n"

" v.resize(entries + 2);\n"

" v[0] = 1;\n"

"}\n");

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

checkNormal("void f(size_t entries) {\n"

" std::vector<uint8_t> v;\n"

" if (v.size() < entries)\n"

" v.resize(entries);\n"

" v[0] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:5:error:Out of bounds access in expression 'v[0]' because 'v' is empty.\n", errout.str());

checkNormal("void f(size_t entries) {\n"

" if (entries < 2) return;\n"

" std::vector<uint8_t> v;\n"

" if (v.size() < entries)\n"

" v.resize(entries);\n"

" v[0] = 1;\n"

"}\n");

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

checkNormal("void f(size_t entries) {\n"

" if (entries == 0) return;\n"

" std::vector<uint8_t> v;\n"

" if (v.size() < entries)\n"

" v.resize(entries);\n"

" v[0] = 1;\n"

"}\n");

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

checkNormal("void foo(std::vector<int>* PArr, int n) {\n"

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

" if (!PArr)\n"

" PArr = &Arr;\n"

" PArr->resize(n);\n"

" for (int i = 0; i < n; ++i)\n"

" (*PArr)[i] = 1;\n"

"}\n");

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

checkNormal("int f() {\n"

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

" std::vector<int> * pv = &v;\n"

" return (*pv).at(42);\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in expression '(*pv).at(42)' because '*pv' is empty.\n",

errout.str());

checkNormal("std::string f(const char* DirName) {\n"

" if (DirName == nullptr)\n"

" return {};\n"

" std::string Name{ DirName };\n"

" if (!Name.empty() && Name.back() != '\\\\')\n"

" Name += '\\\\';\n"

" return Name;\n"

"}\n");

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

checkNormal("bool f(bool b) {\n"

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

" if (b)\n"

" v.push_back(0);\n"

" for(auto i:v)\n"

" if (v[i] > 0)\n"

" return true;\n"

" return false;\n"

"}\n");

ASSERT_EQUALS("test.cpp:5:style:Consider using std::any_of algorithm instead of a raw loop.\n", errout.str());

checkNormal("std::vector<int> range(int n);\n"

"bool f(bool b) {\n"

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

" if (b)\n"

" v.push_back(1);\n"

" assert(range(v.size()).size() == v.size());\n"

" for(auto i:range(v.size()))\n"

" if (v[i] > 0)\n"

" return true;\n"

" return false;\n"

"}\n");

ASSERT_EQUALS("test.cpp:7:style:Consider using std::any_of algorithm instead of a raw loop.\n", errout.str());

checkNormal("bool g();\n"

"int f(int x) {\n"

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

" if (g())\n"

" v.emplace_back(x);\n"

" const auto n = (int)v.size();\n"

" for (int i = 0; i < n; ++i)\n"

" if (v[i] > 0)\n"

" return i;\n"

" return 0;\n"

"}\n");

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

checkNormal("bool g();\n"

"int f(int x) {\n"

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

" if (g())\n"

" v.emplace_back(x);\n"

" const auto n = static_cast<int>(v.size());\n"

" for (int i = 0; i < n; ++i)\n"

" if (v[i] > 0)\n"

" return i;\n"

" return 0;\n"

"}\n");

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

checkNormal("bool g();\n"

"void f(int x) {\n"

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

" if (g())\n"

" v.emplace_back(x);\n"

" const int n = v.size();\n"

" h(n);\n"

" for (int i = 0; i < n; ++i)\n"

" h(v[i]);\n"

"}\n");

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

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

" if(v.size() >=1 && v[0] == 4 && v[1] == 2){}\n"

"}\n");

ASSERT_EQUALS("test.cpp:2:warning:Either the condition 'v.size()>=1' is redundant or v size can be 1. Expression 'v[1]' cause access out of bounds.\n"

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

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

checkNormal("int f(int x, int y) {\n"

" std::vector<int> a = {0,1,2};\n"

" if(x<2)\n"

" y = a[x] + 1;\n"

" else\n"

" y = a[x];\n"

" return y;\n"

"}\n");

ASSERT_EQUALS(

"test.cpp:6:warning:Either the condition 'x<2' is redundant or 'x' can have the value greater or equal to 3. Expression 'a[x]' cause access out of bounds.\n"

"test.cpp:3:note:condition 'x<2'\n"

"test.cpp:6:note:Access out of bounds\n",

errout.str());

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

" if (v.size() > 3)\n"

" return v[v.size() - 3];\n"

" return 0;\n"

"}\n");

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

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

" v[v.size() - 1];\n"

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

"}\n");

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

checkNormal("void f(int n) {\n"

" std::vector<int> v = {1, 2, 3, 4};\n"

" const int i = qMin(n, v.size());\n"

" if (i > 1)\n"

" v[i] = 1;\n"

"}\n");

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

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

" if (i > -1) {\n"

" v.erase(v.begin() + i);\n"

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

" }\n"

"}\n");

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

checkNormal("void g(const char *, ...) { exit(1); }\n" // #10025

"void f(const char c[]) {\n"

" std::vector<int> v = get();\n"

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

" g(\"\", c[0]);\n"

" return h(&v[0], v.size()); \n"

"}\n");

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

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

" if (i <= (int)v.size()) {\n"

" if (v[i]) {}\n"

" }\n"

" if (i <= static_cast<int>(v.size())) {\n"

" if (v[i]) {}\n"

" }\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:warning:Either the condition 'i<=(int)v.size()' is redundant or 'i' can have the value v.size(). Expression 'v[i]' cause access out of bounds.\n"

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

"test.cpp:3:note:Access out of bounds\n"

"test.cpp:6:warning:Either the condition 'i<=static_cast<int>(v.size())' is redundant or 'i' can have the value v.size(). Expression 'v[i]' cause access out of bounds.\n"

"test.cpp:5:note:condition 'i<=static_cast<int>(v.size())'\n"

"test.cpp:6:note:Access out of bounds\n",

errout.str());

check("template<class Iterator>\n"

"void b(Iterator d) {\n"

" std::string c = \"a\";\n"

" d + c.length();\n"

"}\n"

"void f() {\n"

" std::string buf;\n"

" b(buf.begin());\n"

"}\n",

true);

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in expression 'd+c.length()' because 'buf' is empty.\n",

errout.str());

check("template<class Iterator>\n"

"void b(Iterator d) {\n"

" std::string c = \"a\";\n"

" sort(d, d + c.length());\n"

"}\n"

"void f() {\n"

" std::string buf;\n"

" b(buf.begin());\n"

"}\n",

true);

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

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

" return !v.empty() ? 42 : v.back();\n"

"}\n",

true);

ASSERT_EQUALS(

"test.cpp:2:warning:Either the condition 'v.empty()' is redundant or expression 'v.back()' cause access out of bounds.\n"

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

"test.cpp:2:note:Access out of bounds\n",

errout.str());

check("std::vector<int> g() {\n" // #10779

" std::vector<int> v(10);\n"

" for(int i = 0; i <= 10; ++i)\n"

" v[i] = 42;\n"

" return v;\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[i]', if 'v' size is 10 and 'i' is 10\n",

errout.str());

check("void f() {\n"

" int s = 2;\n"

" std::vector <int> v(s);\n"

" v[100] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 2 and '100' is 100\n",

errout.str());

check("void f() {\n"

" std::vector <int> v({ 1, 2, 3 });\n"

" v[100] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",

errout.str());

check("void f() {\n"

" char c[] = { 1, 2, 3 };\n"

" std::vector<char> v(c, sizeof(c) + c);\n"

" v[100] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",

errout.str());

check("void f() {\n"

" char c[] = { 1, 2, 3 };\n"

" std::vector<char> v{ c, c + sizeof(c) };\n"

" v[100] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",

errout.str());

check("void f() {\n"

" int i[] = { 1, 2, 3 };\n"

" std::vector<int> v(i, i + sizeof(i) / 4);\n"

" v[100] = 1;\n"

"}\n");

ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",

errout.str());

check("void f() {\n" // #6615

" int i[] = { 1, 2, 3 };\n"

" std::vector<int> v(i, i + sizeof(i) / sizeof(int));\n"

" v[100] = 1;\n"

"}\n");

TODO_ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",

"",

errout.str());

check("void f() {\n"

" std::array<int, 10> a = {};\n"

" a[10];\n"

" constexpr std::array<int, 10> b = {};\n"

" b[10];\n"

" const std::array<int, 10> c = {};\n"

" c[10];\n"

" static constexpr std::array<int, 10> d = {};\n"

" d[10];\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 'a[10]', if 'a' size is 10 and '10' is 10\n"

"test.cpp:5:error:Out of bounds access in 'b[10]', if 'b' size is 10 and '10' is 10\n"

"test.cpp:7:error:Out of bounds access in 'c[10]', if 'c' size is 10 and '10' is 10\n"

"test.cpp:9:error:Out of bounds access in 'd[10]', if 'd' size is 10 and '10' is 10\n",

errout.str());

check("struct test_fixed {\n"

" std::array<int, 10> array = {};\n"

" void index(int i) { array[i]; }\n"

"};\n"

"void f() {\n"

" test_fixed x = test_fixed();\n"

" x.index(10);\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 'array[i]', if 'array' size is 10 and 'i' is 10\n",

errout.str());

check("struct test_constexpr {\n"

" static constexpr std::array<int, 10> array = {};\n"

" void index(int i) { array[i]; }\n"

"};\n"

"void f() {\n"

" test_constexpr x = test_constexpr();\n"

" x.index(10);\n"

"}\n");

ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 'array[i]', if 'array' size is 10 and 'i' is 10\n",

errout.str());

checkNormal("struct A {\n"

" const std::vector<int>& v;\n"

" A(const std::vector<int>& x) : v(x)\n"

" {}\n"

" int f() const {\n"

" return v[0];\n"

" }\n"

"};\n");

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

checkNormal("struct A {\n"

" static const std::vector<int> v;\n"

" int f() const {\n"

" return v[0];\n"

" }\n"

"};\n"

"const std::vector<int> A::v = {1, 2};\n");

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

checkNormal("struct a {\n"

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

"};\n"

"int f(const a& b) {\n"

" auto c = b.g();\n"

" assert(not c.empty());\n"

" int d = c.front();\n"

" return d;\n"

"}\n");

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

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

" std::map<int, std::string> m = { { 1, \"1\" } };\n"

" return m.at(1);\n"

"}\n");

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

checkNormal("struct A {\n"

" virtual void init_v(std::vector<int> *v) = 0;\n"

"};\n"

"A* create_a();\n"

"struct B {\n"

" B() : a(create_a()) {}\n"

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

" a->init_v(v);\n"

" }\n"

" A* a;\n"

"};\n"

"void f() {\n"

" B b;\n"

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

" b.init_v(&v);\n"

" v[0];\n"

"}\n");

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

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

" if (v->empty())\n"

" v->push_back(1);\n"

" auto x = v->back();\n"

"}\n");

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

checkNormal("template <typename T, uint8_t count>\n"

"struct Foo {\n"

" std::array<T, count> items = {0};\n"

" T maxCount = count;\n"

" explicit Foo(const T& maxValue = (std::numeric_limits<T>::max)()) : maxCount(maxValue) {}\n"

" bool Set(const uint8_t idx) {\n"

" if (CheckBounds(idx) && items[idx] < maxCount) {\n"

" items[idx] += 1;\n"

" return true;\n"

" }\n"

" return false;\n"

" }\n"

" static bool CheckBounds(const uint8_t idx) { return idx < count; }\n"

"};\n"

"void f() {\n"

" Foo<uint8_t, 42U> x;\n"

" if (x.Set(42U)) {}\n"

"}\n");

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

}

void outOfBoundsSymbolic()

{

check("void foo(std::string textline, int col) {\n"

" if(col > textline.size())\n"

" return false;\n"

" int x = textline[col];\n"

"}\n");

ASSERT_EQUALS(

"[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition 'col>textline.size()' is redundant or 'col' can have the value textline.size(). Expression 'textline[col]' cause access out of bounds.\n",

errout.str());

}

void outOfBoundsIndexExpression() {

setMultiline();

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

" s[s.size()] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 's.size()' is out of bounds.\n", errout.str());

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

" s[s.size()+1] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 's.size()+1' is out of bounds.\n", errout.str());

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

" s[1+s.size()] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index '1+s.size()' is out of bounds.\n", errout.str());

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

" s[x*s.size()] = 1;\n"

"}");

ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 'x*s.size()' is out of bounds.\n", errout.str());

checkNormal("bool f(std::string_view& sv) {\n" // #10031

" return sv[sv.size()] == '\\0';\n"

"}\n");

ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of sv, index 'sv.size()' is out of bounds.\n", errout.str());

}

void outOfBoundsIterator() {

check("int f() {\n"

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

" auto it = v.begin();\n"

" return *it;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:4]: (error) Out of bounds access in expression 'it' because 'v' is empty.\n",

errout.str());

check("int f() {\n"

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

" v.push_back(0);\n"

" auto it = v.begin() + 1;\n"

" return *it;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:5]: (error) Out of bounds access in 'it', if 'v' size is 1 and 'it' is at position 1 from the beginning\n",

errout.str());

check("int f() {\n"

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

" v.push_back(0);\n"

" auto it = v.end() - 1;\n"

" return *it;\n"

"}\n");

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

check("int f() {\n"

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

" v.push_back(0);\n"

" auto it = v.end() - 2;\n"

" return *it;\n"

"}\n");

ASSERT_EQUALS("[test.cpp:5]: (error) Out of bounds access in 'it', if 'v' size is 1 and 'it' is at position 2 from the end\n",

errout.str());

check("void g(int);\n"

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

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

" if (!m.empty()) {\n"

" g(m.begin()->second);\n"

" }\n"

"}\n");

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

check("void f() {\n"

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

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

" *it = 1;\n"