/*

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

* Copyright (C) 2007-2015 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 "tokenize.h"

#include "tokenlist.h"

#include "checkmemoryleak.h"

#include "testsuite.h"

#include "symboldatabase.h"

#include "preprocessor.h"

class TestMemleak : private TestFixture {

public:

TestMemleak() : TestFixture("TestMemleak") {

}

private:

Settings settings;

void run() {

TEST_CASE(testFunctionReturnType);

TEST_CASE(open);

}

CheckMemoryLeak::AllocType functionReturnType(const char code[]) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

CheckMemoryLeak c(&tokenizer, this, &settings);

return c.functionReturnType(&tokenizer.getSymbolDatabase()->scopeList.front().functionList.front());

}

void testFunctionReturnType() {

{

const char code[] = "const char *foo()\n"

"{ return 0; }";

ASSERT_EQUALS(CheckMemoryLeak::No, functionReturnType(code));

}

{

const char code[] = "Fred *newFred()\n"

"{ return new Fred; }";

ASSERT_EQUALS(CheckMemoryLeak::New, functionReturnType(code));

}

{

const char code[] = "char *foo()\n"

"{ return new char[100]; }";

ASSERT_EQUALS(CheckMemoryLeak::NewArray, functionReturnType(code));

}

{

const char code[] = "char *foo()\n"

"{\n"

" char *p = new char[100];\n"

" return p;\n"

"}";

ASSERT_EQUALS(CheckMemoryLeak::NewArray, functionReturnType(code));

}

}

void open() {

const char code[] = "class A {\n"

" static int open() {\n"

" return 1;\n"

" }\n"

"\n"

" A() {\n"

" int ret = open();\n"

" }\n"

"};\n";

// Clear the error buffer..

errout.str("");

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

// there is no allocation

const Token *tok = Token::findsimplematch(tokenizer.tokens(), "ret =");

CheckMemoryLeak check(&tokenizer, 0, &settings);

ASSERT_EQUALS(CheckMemoryLeak::No, check.getAllocationType(tok->tokAt(2), 1));

}

};

REGISTER_TEST(TestMemleak)

class TestMemleakInFunction : public TestFixture {

public:

TestMemleakInFunction() : TestFixture("TestMemleakInFunction") {

}

private:

Settings settings0;

Settings settings1;

Settings settings2;

void check(const char code[], bool c = false, bool posix = false, bool experimental = false, Settings *settings = nullptr) {

// Clear the error buffer..

errout.str("");

if (!settings)

settings = &settings1;

settings->experimental = experimental;

settings->standards.posix = posix;

// Tokenize..

Tokenizer tokenizer(settings, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, c?"test.c":"test.cpp");

tokenizer.simplifyTokenList2();

// Check for memory leaks..

CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, settings, this);

checkMemoryLeak.checkReallocUsage();

checkMemoryLeak.check();

}

void run() {

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

LOAD_LIB_2(settings1.library, "posix.cfg");

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

// Check that getcode works correctly..

TEST_CASE(testgetcode);

// check that call_func works correctly..

TEST_CASE(call_func);

// Check that simplifycode works correctly..

TEST_CASE(simplifycode);

// Check that errors are found..

TEST_CASE(findleak);

TEST_CASE(simple5);

TEST_CASE(simple7);

TEST_CASE(simple9); // Bug 2435468 - member function "free"

TEST_CASE(simple11);

TEST_CASE(nonstd_free);

TEST_CASE(new_nothrow);

TEST_CASE(staticvar);

TEST_CASE(externvar);

TEST_CASE(referencevar); // 3954 - false positive for reference pointer

TEST_CASE(alloc_alloc_1);

TEST_CASE(ifelse6);

TEST_CASE(ifelse7);

TEST_CASE(ifelse8);

TEST_CASE(ifelse10);

TEST_CASE(if4);

TEST_CASE(if7); // Bug 2401436

TEST_CASE(if8); // Bug 2458532

TEST_CASE(if9); // if (realloc)

TEST_CASE(if10); // else if (realloc)

TEST_CASE(if11);

TEST_CASE(forwhile5);

TEST_CASE(forwhile6);

TEST_CASE(forwhile8); // Bug 2429936

TEST_CASE(forwhile9);

TEST_CASE(forwhile10);

TEST_CASE(forwhile11);

TEST_CASE(switch2);

TEST_CASE(switch3);

TEST_CASE(ret5); // Bug 2458436 - return use

TEST_CASE(ret6);

TEST_CASE(ret7);

TEST_CASE(ret8);

TEST_CASE(mismatch1);

TEST_CASE(mismatch2);

TEST_CASE(mismatch3);

TEST_CASE(mismatch4);

TEST_CASE(mismatch5);

TEST_CASE(mismatch6);

TEST_CASE(mismatchSize);

TEST_CASE(func3);

TEST_CASE(func4);

TEST_CASE(func5);

TEST_CASE(func6);

TEST_CASE(func7);

TEST_CASE(func9); // Embedding the function call in a if-condition

TEST_CASE(func10); // Bug 2458510 - Function pointer

TEST_CASE(func11); // Bug 2458510 - Function pointer

TEST_CASE(func12);

TEST_CASE(func13);

TEST_CASE(func14);

TEST_CASE(func15);

TEST_CASE(func16);

TEST_CASE(func17);

TEST_CASE(func18);

TEST_CASE(func19); // Ticket #2056 - if (!f(p)) return 0;

TEST_CASE(func20); // Ticket #2182 - exit is not handled

TEST_CASE(func21); // Ticket #2569

TEST_CASE(func22); // Ticket #2668

TEST_CASE(func23); // Ticket #2667

TEST_CASE(func24); // Ticket #2705

TEST_CASE(func25); // Ticket #2904

TEST_CASE(func26);

TEST_CASE(func27); // Ticket #2773

TEST_CASE(func28); // Ticket #3236

TEST_CASE(allocfunc1);

TEST_CASE(allocfunc2);

TEST_CASE(allocfunc3);

TEST_CASE(allocfunc4);

TEST_CASE(allocfunc5);

TEST_CASE(allocfunc6);

TEST_CASE(allocfunc7);

TEST_CASE(allocfunc8);

TEST_CASE(allocfunc9);

TEST_CASE(allocfunc10);

TEST_CASE(allocfunc11);

TEST_CASE(allocfunc12); // #3660: allocating and returning non-local pointer => not allocfunc

TEST_CASE(allocfunc13); // Ticket #4494 and #4540 - class function

TEST_CASE(allocfunc14); // Use pointer before returning it

TEST_CASE(throw1);

TEST_CASE(throw2);

TEST_CASE(linux_list_1);

TEST_CASE(linux_list_2);

TEST_CASE(sizeof1);

TEST_CASE(realloc1);

TEST_CASE(realloc2);

TEST_CASE(realloc3);

TEST_CASE(realloc4);

TEST_CASE(realloc5);

TEST_CASE(realloc6);

TEST_CASE(realloc7);

TEST_CASE(realloc8);

TEST_CASE(realloc9);

TEST_CASE(realloc10);

TEST_CASE(realloc11);

TEST_CASE(realloc12);

TEST_CASE(realloc13);

TEST_CASE(realloc14);

TEST_CASE(realloc15);

TEST_CASE(realloc16);

TEST_CASE(assign1);

TEST_CASE(varid);

TEST_CASE(cast1);

// Using deallocated memory:

// * It is ok to take the address to deallocated memory

// * It is not ok to dereference a pointer to deallocated memory

TEST_CASE(dealloc_use);

TEST_CASE(dealloc_use_2);

TEST_CASE(dealloc_use_3);

// free a free'd pointer

TEST_CASE(freefree1);

TEST_CASE(freefree2);

TEST_CASE(freefree3); // #4236 - FP. bar(&p)

TEST_CASE(strcpy_result_assignment);

TEST_CASE(strcat_result_assignment);

TEST_CASE(all1); // Extra checking when --all is given

TEST_CASE(malloc_constant_1); // Check that the malloc constant matches the type

// Calls to unknown functions.. they may throw exception, quit the program, etc

TEST_CASE(unknownFunction1);

TEST_CASE(unknownFunction2);

TEST_CASE(unknownFunction4);

TEST_CASE(unknownFunction5);

// detect leak in class member function..

TEST_CASE(class1);

TEST_CASE(class2);

TEST_CASE(autoptr1);

TEST_CASE(if_with_and);

TEST_CASE(assign_pclose);

// Using the function "exit"

TEST_CASE(exit2);

TEST_CASE(exit4);

TEST_CASE(exit5);

TEST_CASE(exit6);

TEST_CASE(exit7);

TEST_CASE(noreturn);

TEST_CASE(strndup_function);

TEST_CASE(tmpfile_function);

TEST_CASE(fcloseall_function);

TEST_CASE(file_functions);

TEST_CASE(getc_function);

TEST_CASE(open_function);

TEST_CASE(creat_function);

TEST_CASE(close_function);

TEST_CASE(fd_functions);

TEST_CASE(pointer_to_pointer);

TEST_CASE(dealloc_and_alloc_in_func);

// Unknown syntax

TEST_CASE(unknownSyntax1);

TEST_CASE(knownFunctions);

TEST_CASE(same_function_name);

// #1440 - Check function parameters also..

TEST_CASE(functionParameter);

// setjmp/longjmp..

TEST_CASE(jmp);

TEST_CASE(trac1949);

TEST_CASE(trac2540);

// #2662: segfault because of endless recursion (call_func -> getAllocationType -> functionReturnType -> call_func ..)

TEST_CASE(trac2662);

// #1879 non regression test case

TEST_CASE(trac1879);

TEST_CASE(ptrptr);

TEST_CASE(c_code);

TEST_CASE(gnucfg);

TEST_CASE(trac3991);

TEST_CASE(crash);

}

std::string getcode(const char code[], const char varname[], bool classfunc=false) {

// Clear the error buffer..

errout.str("");

settings2.standards.posix = true;

// Tokenize..

Tokenizer tokenizer(&settings2, this);

std::istringstream istr(code);

if (!tokenizer.tokenize(istr, "test.cpp"))

return "";

tokenizer.simplifyTokenList2();

const unsigned int varId(Token::findmatch(tokenizer.tokens(), varname)->varId());

// getcode..

CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, &settings2, nullptr);

std::list<const Token *> callstack;

callstack.push_back(0);

CheckMemoryLeak::AllocType allocType, deallocType;

allocType = deallocType = CheckMemoryLeak::No;

Token *tokens = checkMemoryLeak.getcode(tokenizer.tokens(), callstack, varId, allocType, deallocType, classfunc, 1);

// stringify..

std::ostringstream ret;

for (const Token *tok = tokens; tok; tok = tok->next())

ret << tok->str();

TokenList::deleteTokens(tokens);

return ret.str();

}

void testgetcode() {

// alloc;

ASSERT_EQUALS(";;alloc;", getcode("int *a = malloc(100);", "a"));

TODO_ASSERT_EQUALS(";;alloc;", ";;alloccallfunc;", getcode("int *a = ::malloc(100);", "a"));

ASSERT_EQUALS(";;alloc;", getcode("int *a = new int;", "a"));

ASSERT_EQUALS(";;alloc;", getcode("int *a = new int[10];", "a"));

ASSERT_EQUALS(";;alloc;", getcode("int **a = new int*[10];", "a"));

ASSERT_EQUALS(";;alloc;", getcode("int * const a = new int[10];", "a"));

ASSERT_EQUALS(";;alloc;", getcode("const int * const a = new int[10];", "a"));

ASSERT_EQUALS(";;alloc;", getcode("int i = open(a,b);", "i"));

ASSERT_EQUALS(";;assign;", getcode("int i = open();", "i"));

// alloc; return use;

ASSERT_EQUALS(";;alloc;returnuse;", getcode("int *a = new int[10]; return a;", "a"));

ASSERT_EQUALS(";;alloc;returnuse;", getcode("char *a = new char[100]; return (char *)a;", "a"));

// alloc; return;

ASSERT_EQUALS(";;alloc;return;", getcode("char *s = new char[100]; return 0;", "s"));

ASSERT_EQUALS(";;alloc;return;", getcode("char *s = new char[100]; return s[0];", "s"));

ASSERT_EQUALS(";;alloc;return;", getcode("char *s = new char[100]; return strcmp(s,x);", "s"));

// lock/unlock..

ASSERT_EQUALS(";;alloc;", getcode("int a; __cppcheck_lock();", ""));

ASSERT_EQUALS(";;callfunc;", getcode("int a; __cppcheck_lock();", "a"));

ASSERT_EQUALS(";;dealloc;", getcode("int a; __cppcheck_unlock();", ""));

ASSERT_EQUALS(";;callfunc;", getcode("int a; __cppcheck_unlock();", "a"));

// dealloc;

ASSERT_EQUALS(";;dealloc;", getcode("char *s; free(s);", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; free((void *)s);", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; free((void *)(s));", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; free(reinterpret_cast<void *>(s));", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; ::free(s);", "s")); // #2802

ASSERT_EQUALS(";;dealloc;", getcode("char *s; delete s;", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; delete (s);", "s"));

TODO_ASSERT_EQUALS(";;dealloc;",

";;;", getcode("char *s; delete (void *)(s);", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; delete [] s;", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; delete [] (s);", "s"));

ASSERT_EQUALS(";;dealloc;", getcode("void *p; foo(fclose(p));", "p"));

ASSERT_EQUALS(";;dealloc;", getcode("void *p; foo(close(p));", "p"));

ASSERT_EQUALS(";;;;", getcode("FILE *f1; FILE *f2; fclose(f1);", "f2"));

ASSERT_EQUALS(";;returnuse;", getcode("FILE *f; return fclose(f) == EOF ? 1 : 2;", "f"));

ASSERT_EQUALS(";;dealloc;", getcode("char *s; s ? free(s) : 0;", "s"));

// if..

ASSERT_EQUALS(";;if{}", getcode("char *s; if (a) { }", "s"));

ASSERT_EQUALS(";;dealloc;ifv{}", getcode("FILE *f; if (fclose(f)) { }", "f"));

ASSERT_EQUALS(";;if(!var){}else{}", getcode("char *s; if (!s) { } else { }", "s"));

TODO_ASSERT_EQUALS(";;ifv{}",";;if{}", getcode("char *s; if (a && s) { }", "s"));

ASSERT_EQUALS(";;ifv{}", getcode("char *s; if (s && a) { }", "s"));

ASSERT_EQUALS(";;;ifv{}", getcode("char *s; int a; if (a && s) { }", "s"));

ASSERT_EQUALS(";;;ifv{}", getcode("char *s; int a; if (s && a) { }", "s"));

ASSERT_EQUALS(";;ifv{}", getcode("char *s; if (a || s) { }", "s"));

ASSERT_EQUALS(";;ifv{}", getcode("char *s; if (s || a) { }", "s"));

ASSERT_EQUALS(";;if(!var){}", getcode("char *s; if (a && !s) { }", "s"));

ASSERT_EQUALS(";;ifv{}", getcode("char *s; if (foo(!s)) { }", "s"));

ASSERT_EQUALS(";;;if{dealloc;};if{dealloc;return;}assign;returnuse;", getcode("char *buf, *tmp; tmp = realloc(buf, 40); if (!(tmp)) { free(buf); return; } buf = tmp; return buf;", "buf"));

ASSERT_EQUALS(";;if{}", getcode("FILE *f; if (fgets(buf,100,f)){}", "f"));

ASSERT_EQUALS(";;alloc;if(var){dealloc;}", getcode("int fd = open(a,b); if (0 < fd) { close(fd); }", "fd"));

ASSERT_EQUALS(";;use;if{}", getcode("char *s; if (x(s)) { }", "s"));

ASSERT_EQUALS(";;use;if{}", getcode("char *s; if (x(&s)) { }", "s"));

ASSERT_EQUALS(";;use;if{}", getcode("char *s; if (!s || x(&s)) { }", "s"));

ASSERT_EQUALS(";;ifv{}", getcode("int ffd; if (ffd<0 && (ffd=a)<0){}", "ffd"));

// if (ticket #2442)

ASSERT_EQUALS(";;;;if(!var){;}ifv{}", getcode("char *s; int x = 0; if (!s) { x = 2; } if (x) { }", "s"));

ASSERT_EQUALS(";;;;if(!var){;}if{}", getcode("char *s; int x = 0; if (!s) { x = 2; } if (y) { }", "s"));

// switch..

ASSERT_EQUALS(";;switch{case;;break;};", getcode("char *s; switch(a){case 1: break;};", "s"));

// loop..

ASSERT_EQUALS(";;loop{}", getcode("char *s; while (a) { }", "s"));

ASSERT_EQUALS(";;loopcallfunc{}", getcode("char *s; while (a()) { }", "s"));

ASSERT_EQUALS(";;loop{}", getcode("char *s; for (a;b;c) { }", "s"));

ASSERT_EQUALS(";;loop{alloc;}", getcode("char *s; for (a;b;c) { s=malloc(10); }", "s"));

ASSERT_EQUALS(";;do{}loop;", getcode("char *s; do { } while (a);", "s"));

ASSERT_EQUALS(";;while1{}", getcode("char *s; while(true) { }", "s"));

ASSERT_EQUALS(";;while1{}", getcode("char *s; for(;;) { }", "s"));

ASSERT_EQUALS(";;while(var){}", getcode("char *s; while (s) { }", "s"));

ASSERT_EQUALS(";;while(!var){}", getcode("char *s; while (!s) { }", "s"));

ASSERT_EQUALS(";;alloc;while(var){}", getcode("int fd = open(a,b); while (fd >= 0) { }", "fd"));

ASSERT_EQUALS(";;alloc;while(!var){}", getcode("int fd = open(a,b); while (fd < 0) { }", "fd"));

// asprintf..

ASSERT_EQUALS(";;alloc;", getcode("char *s; asprintf(&s, \"xyz\");", "s"));

ASSERT_EQUALS(";;alloc;", getcode("char *s; asprintf(&s, \"s: %s\", s);", "s"));

ASSERT_EQUALS(";;;", getcode("char *s; asprintf(&p, \"s: %s\", s);", "s"));

// Since we don't check how the return value is used we must bail out

ASSERT_EQUALS("", getcode("char *s; int ret = asprintf(&s, \"xyz\");", "s"));

TODO_ASSERT_EQUALS(";;alloc;",

"", getcode("char *s; int ret; ret=asprintf(&s, \"xyz\"); if (ret==-1) return;", "s"));

// use..

ASSERT_EQUALS(";;use;", getcode("char *s; a(s);", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; (*a)(s);", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; abc.a(s);", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; s2 = s;", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; s2 = s + 10;", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; s2 = x + s;", "s"));

ASSERT_EQUALS(";;use;if{;}", getcode("char *s; if (foo(s)) ;", "s"));

ASSERT_EQUALS(";;use;", getcode("char *s; map1[s] = 0;", "s"));

ASSERT_EQUALS(";;;use;", getcode("char *p; const char *q; q = p;", "p"));

ASSERT_EQUALS(";;use;;", getcode("char *s; x = {1,s};", "s"));

ASSERT_EQUALS(";{};;alloc;;use;", getcode("struct Foo { }; Foo *p; p = malloc(10); const Foo *q; q = p;", "p"));

ASSERT_EQUALS(";;alloc;use;", getcode("Fred *fred; p.setFred(fred = new Fred);", "fred"));

ASSERT_EQUALS(";;useuse_;", getcode("struct AB *ab; f(ab->a);", "ab"));

ASSERT_EQUALS(";;use;", getcode("struct AB *ab; ab = pop(ab);", "ab"));

// non-use..

ASSERT_EQUALS(";;use_;", getcode("char *s; c = x + s[0];","s"));

ASSERT_EQUALS(";;use_;", getcode("char *s; c = s[0] + x;","s"));

ASSERT_EQUALS(";;use_;", getcode("type *c; y = x + c->y;","c"));

ASSERT_EQUALS(";;use_;", getcode("type *c; y = c->y + x;","c"));

ASSERT_EQUALS(";;use_;", getcode("char *s; s = s + 1;", "s"));

ASSERT_EQUALS(";;dealloc;;", getcode("struct foo *s; free(s); printf(a,sizeof(*s));", "s"));

ASSERT_EQUALS(";;do{dealloc;;}while(var);", getcode("struct foo *s; do{free(s); printf(a,sizeof(*s));}while(s);", "s"));

// use reference

ASSERT_EQUALS(";;callfunc&use;", getcode("struct AB *ab; f(&ab);", "ab"));

// return..

ASSERT_EQUALS(";;return;", getcode("char *s; return;", "s"));

ASSERT_EQUALS(";;returnuse;", getcode("char *s; return s;", "s"));

ASSERT_EQUALS(";;return;", getcode("char *s; return 5 + s[0];", "s"));

// assign..

ASSERT_EQUALS(";;assign;", getcode("char *s; s = 0;", "s"));

ASSERT_EQUALS(";;;", getcode("char *s; s = strcpy(s, p);", "s"));

// callfunc..

ASSERT_EQUALS(";;assign;", getcode("char *s; s = a();", "s"));

ASSERT_EQUALS(";;callfunc;", getcode("char *s; a();", "s"));

ASSERT_EQUALS(";;callfunc;", getcode("char *s; abc.a();", "s"));

ASSERT_EQUALS(";;;", getcode("char *s; x = a();", "s")); // the function call is irrelevant

// exit..

ASSERT_EQUALS(";;exit;", getcode("char *s; exit(0);", "s"));

ASSERT_EQUALS(";;callfunc;", getcode("char *s; _exit(0);", "s")); // not in std.cfg

ASSERT_EQUALS(";;exit;", getcode("char *s; abort();", "s"));

ASSERT_EQUALS(";;callfunc;", getcode("char *s; err(0);", "s")); // not in std.cfg

ASSERT_EQUALS(";;if{exit;}", getcode("char *s; if (a) { exit(0); }", "s"));

// list_for_each

ASSERT_EQUALS(";;exit;{}", getcode("char *s; list_for_each(x,y,z) { }", "s"));

// open/close

ASSERT_EQUALS(";;alloc;if(var){dealloc;}", getcode("int f; f=open(a,b); if(f>=0)close(f);", "f"));

ASSERT_EQUALS(";;alloc;if(var){dealloc;}", getcode("int f; f=open(a,b); if(f>-1)close(f);", "f"));

ASSERT_EQUALS(";;alloc;ifv{;}", getcode("int f; f=open(a,b); if(f!=-1 || x);", "f"));

ASSERT_EQUALS(";;;dealloc;loop{}", getcode(";int f; while (close(f) == -1) { }", "f"));

ASSERT_EQUALS(";;;dealloc;assign;;", getcode(";int res; res = close(res);", "res"));

ASSERT_EQUALS(";;dealloc;", getcode("int f; e |= fclose(f);", "f"));

ASSERT_EQUALS(";;dealloc;", getcode("int f; e += fclose(f);", "f"));

ASSERT_EQUALS(";;dealloc;", getcode("int f; foo(fclose(f));", "f"));

// fcloseall..

ASSERT_EQUALS(";;alloc;;", getcode("char *s; s = malloc(10); fcloseall();", "s"));

ASSERT_EQUALS(";;alloc;dealloc;", getcode("FILE *f; f = fopen(a,b); fcloseall();", "f"));

// call memcpy in class function..

ASSERT_EQUALS(";;alloc;;", getcode("char *s; s = new char[10]; memcpy(s,a);", "s", true));

// #2112 - Segmentation fault in the getcode function

ASSERT_THROW(getcode("page *one = foo();\n"

"ASSERT(one, return 0)\n"

"const int two = rand();\n"

"return 0;\n"

"}", "one"), InternalError);

// ticket #2336: calling member function with same name as a white_list function

ASSERT_EQUALS(";;use;", getcode("char *s; foo.write(s);", "s"));

// #2473 - inner struct

ASSERT_EQUALS(";;alloc;{;;};dealloc;",

getcode("char *s = new char[10];\n"

"struct ab { int a, b; };\n"

"delete [] s;\n", "s"));

// #4405 - catch

ASSERT_EQUALS(";;catch{}", getcode("char *s; catch(err) { }", "s"));

}

bool test_white_list(const std::string& str, bool cpp = true) const {

return CheckMemoryLeakInFunction::test_white_list(str, &settings1, cpp);

}

void call_func() const {

// whitelist..

ASSERT_EQUALS(true, test_white_list("qsort"));

ASSERT_EQUALS(true, test_white_list("scanf"));

ASSERT_EQUALS(true, test_white_list("sscanf"));

// #1293

ASSERT_EQUALS(true, test_white_list("time"));

ASSERT_EQUALS(true, test_white_list("asctime"));

ASSERT_EQUALS(true, test_white_list("asctime_r"));

ASSERT_EQUALS(true, test_white_list("ctime"));

ASSERT_EQUALS(true, test_white_list("ctime_r"));

ASSERT_EQUALS(true, test_white_list("gmtime"));

ASSERT_EQUALS(true, test_white_list("gmtime_r"));

ASSERT_EQUALS(true, test_white_list("localtime"));

ASSERT_EQUALS(true, test_white_list("localtime_r"));

ASSERT_EQUALS(true, test_white_list("memcmp"));

ASSERT_EQUALS(true, test_white_list("gets"));

ASSERT_EQUALS(true, test_white_list("vprintf"));

ASSERT_EQUALS(true, test_white_list("vfprintf"));

ASSERT_EQUALS(true, test_white_list("vsprintf"));

ASSERT_EQUALS(true, test_white_list("snprintf"));

ASSERT_EQUALS(true, test_white_list("vsnprintf"));

ASSERT_EQUALS(true, test_white_list("delete", true));

ASSERT_EQUALS(false, test_white_list("delete", false));

static const char * const call_func_white_list[] = {

"access", "asprintf", "atof", "atoi", "atol", "chdir", "chmod", "clearerr", "chown"

, "fchmod", "fcntl", "fdatasync", "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets"

, "flock", "for", "fprintf", "fputc", "fputs", "fread", "free", "freopen", "fscanf", "fseek"

, "fseeko", "fsetpos", "fstat", "fsync", "ftell", "ftello", "ftruncate"

, "fwrite", "getc", "if", "ioctl", "lockf", "lseek", "open", "memchr", "memcpy"

, "memmove", "memset", "mkstemp", "perror", "posix_fadvise", "posix_fallocate", "pread"

, "printf", "puts", "pwrite", "read", "readahead", "readdir", "readdir_r", "readv"

, "realloc", "return", "rewind", "rewinddir", "scandir", "seekdir"

, "setbuf", "setbuffer", "setlinebuf", "setvbuf", "snprintf", "sprintf", "stpcpy", "strcasecmp"

, "strcat", "strchr", "strcmp", "strcpy", "stricmp", "strlen", "strncat", "strncmp"

, "strncpy", "strrchr", "strspn" ,"strstr", "strtod", "strtol", "strtoul", "switch"

, "sync_file_range", "telldir", "typeid", "while", "write", "writev", "lstat", "stat"

, "_open", "_wopen", "vscanf", "vsscanf", "vfscanf", "vasprintf", "utime", "utimes", "unlink"

, "tempnam", "system", "symlink", "strpbrk", "strncasecmp", "strdup", "strcspn", "strcoll"

, "setlocale", "sethostname", "rmdir", "rindex", "rename", "remove", "adjtime", "creat", "execle"

, "execl", "execlp", "execve", "execv", "fmemopen", "fnmatch", "fopencookie", "fopen"

, "getgrnam", "gethostbyaddr", "getnetbyname", "getopt", "getopt_long", "getprotobyname", "getpwnam"

, "getservbyname", "getservbyport", "glob", "index", "inet_addr", "inet_aton", "inet_network"

, "initgroups", "link", "mblen", "mbstowcs", "mbtowc", "mkdir", "mkfifo", "mknod", "obstack_printf"

, "obstack_vprintf", "opendir", "parse_printf_format", "pathconf", "popen", "psignal"

, "readlink", "regcomp", "strxfrm", "wordexp", "sizeof", "strtok"

};

for (unsigned int i = 0; i < (sizeof(call_func_white_list) / sizeof(char *)); ++i) {

bool ret = test_white_list(call_func_white_list[i]);

ASSERT_EQUALS("", ret ? "" : call_func_white_list[i]);

}

}

std::string simplifycode(const char code[]) {

// Clear the error buffer..

errout.str("");

// Tokenize..

std::istringstream istr(code);

Tokenizer tokenizer(&settings0, this);

tokenizer.list.createTokens(istr, "test.cpp");

// replace "if ( ! var )" => "if(!var)"

for (Token *tok = tokenizer.list.front(); tok; tok = tok->next()) {

if (Token::Match(tok, "if|while ( var )")) {

Token::eraseTokens(tok, tok->tokAt(4));

tok->str(tok->str() + "(var)");

}

else if (Token::Match(tok, "if|while ( ! var )")) {

Token::eraseTokens(tok, tok->tokAt(5));

tok->str(tok->str() + "(!var)");

}

}

CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, &settings0, this);

checkMemoryLeak.simplifycode(tokenizer.list.front());

return tokenizer.tokens()->stringifyList(0, false);

}

// Test that the CheckMemoryLeaksInFunction::simplifycode works

void simplifycode() {

ASSERT_EQUALS(";", simplifycode("; ; ; ;"));

ASSERT_EQUALS(";", simplifycode("; if ;"));

ASSERT_EQUALS("alloc ;", simplifycode("alloc ; if ; if(var) ; ifv ; if(!var) ;"));

ASSERT_EQUALS("alloc ;", simplifycode("alloc ; if ; else ;"));

// use..

ASSERT_EQUALS("; use ; }", simplifycode("; use use ; }"));

ASSERT_EQUALS("; use ; }", simplifycode("; use use_ ; }"));

ASSERT_EQUALS("; use ; }", simplifycode("; use_ use ; }"));

ASSERT_EQUALS("; use ; }", simplifycode("; &use use ; }"));

ASSERT_EQUALS("; use ; }", simplifycode("; use &use ; }"));

ASSERT_EQUALS("; alloc ; dealloc ; }", simplifycode("; alloc ; use ; use ; if use ; dealloc ; }"));

// if, else..

ASSERT_EQUALS("; alloc ; if break ; dealloc ;", simplifycode("; alloc ; if { break; } dealloc ;"));

ASSERT_EQUALS("; alloc ; if continue ; dealloc ;", simplifycode("; alloc ; if { continue; } dealloc ;"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc; if { return use; }"));

ASSERT_EQUALS("; alloc ; dealloc ;", simplifycode("; alloc; if(!var) { return; } dealloc;"));

ASSERT_EQUALS("; alloc ;", simplifycode("; if { alloc; } else { return; }"));

ASSERT_EQUALS("; alloc ; dealloc ;", simplifycode("; alloc ; if(!var) { alloc ; } dealloc ;"));

ASSERT_EQUALS("; use ;", simplifycode("; if(var) use ;"));

ASSERT_EQUALS("; break ;", simplifycode("; if break ; else break ;"));

ASSERT_EQUALS("; alloc ; if return ;", simplifycode("; alloc ; loop { if return ; if continue ; }"));

ASSERT_EQUALS("; alloc ; if return ;", simplifycode("; alloc ; loop { if continue ; else return ; }"));

ASSERT_EQUALS("; alloc ; if dealloc ;", simplifycode("; alloc ; if(!var) { return ; } if { dealloc ; }"));

ASSERT_EQUALS("; if alloc ; else assign ; return use ;", simplifycode("; callfunc ; if callfunc { alloc ; } else { assign ; } return use ;"));

ASSERT_EQUALS("; dealloc ; return ;", simplifycode("; while1 { if callfunc { dealloc ; return ; } else { continue ; } }"));

// remove outer if (#2733)

ASSERT_EQUALS("alloc ; return ; }", simplifycode("alloc ; if { if return use ; } return ; }"));

ASSERT_EQUALS("alloc ; return ; }", simplifycode("alloc ; if { if(var) return use ; } return ; }"));

ASSERT_EQUALS("alloc ; return ; }", simplifycode("alloc ; if(var) { if return use ; } return ; }"));

// "if ; .."

ASSERT_EQUALS("; if xxx ;", simplifycode("; if ; else xxx ;"));

ASSERT_EQUALS("; if(var) xxx ;", simplifycode("; if(!var) ; else xxx ;"));

ASSERT_EQUALS("; if(!var) xxx ;", simplifycode("; if(var) ; else xxx ;"));

ASSERT_EQUALS("; ifv xxx ;", simplifycode("; ifv ; else xxx ;"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc; if { dealloc; return; }"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc; if { return use; }"));

ASSERT_EQUALS("; alloc ; return ;", simplifycode(";alloc;if{return;}return;"));

ASSERT_EQUALS("; alloc ; if assign ; dealloc ;", simplifycode(";alloc;if{assign;}dealloc;"));

// if(var)

ASSERT_EQUALS("; alloc ; return use ;", simplifycode("; alloc ; return use ;"));

ASSERT_EQUALS("; alloc ; return use ;", simplifycode("; alloc ; ifv return ; return use ;"));

// switch..

ASSERT_EQUALS("; alloc ; dealloc ;", simplifycode(";alloc;switch{case;break;};dealloc;"));

ASSERT_EQUALS(";", simplifycode("; switch { case ; return ; default ; break ; }"));

ASSERT_EQUALS(";", simplifycode("; switch { case ; if { return ; } break ; default ; break ; }"));

ASSERT_EQUALS("; use ;", simplifycode("; switch { case ; return ; default ; use ; break ; }"));

ASSERT_EQUALS("; use ;", simplifycode("; while1 { loop { ; } switch { case ; dealloc ; return ; default ; break ; } }"));

ASSERT_EQUALS("; { dealloc ; return ; } }", simplifycode("switch { case ; case ; dealloc ; return ; default ; dealloc ; return ; } }"));

// loops..

ASSERT_EQUALS(";", simplifycode("; loop { ; }"));

ASSERT_EQUALS(";", simplifycode("; loop { break; }"));

ASSERT_EQUALS(";", simplifycode("; loop { if { break; } }"));

ASSERT_EQUALS("; loop alloc ;", simplifycode("; loop { alloc ; }"));

ASSERT_EQUALS("; alloc ; alloc ;", simplifycode("; alloc ; do { alloc ; } loop ;"));

ASSERT_EQUALS("; exit ;", simplifycode("; alloc ; do { } loop ; exit ;"));

ASSERT_EQUALS("; loop use ;", simplifycode("; loop { loop loop use ; } ;"));

ASSERT_EQUALS("; }", simplifycode("; loop { if break ; break ; } ; }"));

ASSERT_EQUALS("; }", simplifycode("; loop { if continue ; if continue ; } ; }"));

{

// ticket #3267

const char expected[] = "; loop if alloc ; if { dealloc ; return ; } }";

ASSERT_EQUALS(expected, simplifycode("; loop { if alloc ; } if { dealloc ; return ; } }"));

ASSERT_EQUALS(expected, simplifycode("; loop { if { alloc ; if(!var) { return ; } } } if { dealloc ; return ; } }"));

}

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc ; while(!var) alloc ;"));

ASSERT_EQUALS("; alloc ; dealloc ; return ;", simplifycode("; alloc ; while1 { if { dealloc ; return ; } }"));

ASSERT_EQUALS("; alloc ; dealloc ; return ;", simplifycode("; alloc ; while1 { if { dealloc ; return ; } if { continue ; } }"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc ; while1 { if { dealloc ; return ; } if { break ; } }"));

ASSERT_EQUALS("; alloc ; use ; }", simplifycode("; alloc ; while1 { if { dealloc ; return ; } continue ; } ; }"));

ASSERT_EQUALS(";", simplifycode("; do { dealloc ; alloc ; } while(var) ;"));

ASSERT_EQUALS("dealloc ; alloc ;", simplifycode("loop { dealloc ; alloc ; }"));

ASSERT_EQUALS("dealloc ; alloc ;", simplifycode("while1 { dealloc ; alloc ; }"));

ASSERT_EQUALS("use ; }", simplifycode("loop { use ; callfunc ; } }"));

ASSERT_EQUALS(";", simplifycode("; loop { if { continue ; } else { if continue ; } }"));

ASSERT_EQUALS(";", simplifycode("; loop { { if continue ; if continue ; } }"));

ASSERT_EQUALS("; use ;", simplifycode("; while1 { if { dealloc ; return ; } if { if { continue ; } } }"));

// scope..

TODO_ASSERT_EQUALS("; assign ; if alloc ; }",

"; assign ; dealloc ; if alloc ; }", simplifycode("; assign ; { dealloc ; if alloc ; } }"));

// callfunc..

ASSERT_EQUALS("; callfunc ; }", simplifycode(";callfunc;}"));

ASSERT_EQUALS(";", simplifycode(";callfunc;;"));

ASSERT_EQUALS("; callfunc ; }", simplifycode(";callfunc callfunc ; }"));

ASSERT_EQUALS("dealloc ; alloc ; return ; }", simplifycode("while1 { dealloc ; alloc ; } callfunc ; return ; }"));

ASSERT_EQUALS("; }", simplifycode("loop callfunc ; }"));

ASSERT_EQUALS("alloc ; dealloc ; }", simplifycode("alloc ; if { dealloc ; callfunc } dealloc ; }")); // #4405

// #2900 - don't report false positive

ASSERT_EQUALS("; alloc ; if { if { dealloc ; callfunc ; } return ; } dealloc ; }",

simplifycode("; alloc ; if { if { dealloc ; callfunc ; } return ; } dealloc ; }"));

// exit..

ASSERT_EQUALS("; exit ;", simplifycode("; alloc; exit;"));

ASSERT_EQUALS("; exit ;", simplifycode("; alloc; if { loop ; } dealloc; exit;"));

ASSERT_EQUALS(";", simplifycode("; if { alloc; exit; }"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc ; if { use; exit; }"));

ASSERT_EQUALS("; alloc ;", simplifycode("; alloc ; if(!var) { exit; }"));

TODO_ASSERT_EQUALS(";",

"; if(var) exit ;", simplifycode("; alloc ; if(var) { exit; }"));

TODO_ASSERT_EQUALS(";\n; alloc ;",

"; alloc ; ifv exit ;", simplifycode("; alloc ; ifv { exit; }"));

// try-catch

ASSERT_EQUALS("; }", simplifycode("; try ; catch exit ; }"));

// dealloc; dealloc;

ASSERT_EQUALS("; alloc ; if dealloc ; dealloc ;", simplifycode("; alloc ; if { dealloc ; } dealloc ;"));

// use ; dealloc ;

ASSERT_EQUALS("; alloc ; use ; if return ; dealloc ;", simplifycode("; alloc ; use ; if { return ; } dealloc ;"));

// #2635 - false negative

ASSERT_EQUALS("; alloc ; return use ; }",

simplifycode("; alloc ; if(!var) { loop { ifv { } } alloc ; } return use; }"));

}

// is there a leak in given code? if so, return the linenr

unsigned int dofindleak(const char code[]) {

// Clear the error buffer..

errout.str("");

settings0.debug = settings0.debugwarnings = true;

// Tokenize..

std::istringstream istr(code);

TokenList list(&settings0);

list.createTokens(istr,"test.cpp");

Token *tokens=list.front();

// replace "if ( ! var )" => "if(!var)"

for (Token *tok = tokens; tok; tok = tok->next()) {

if (tok->str() == "if_var") {

tok->str("if(var)");

}

else if (Token::simpleMatch(tok, "if ( var )")) {

Token::eraseTokens(tok, tok->tokAt(4));

tok->str("if(var)");

}

else if (Token::simpleMatch(tok, "if ( ! var )")) {

Token::eraseTokens(tok, tok->tokAt(5));

tok->str("if(!var)");

}

}

const Token *tok = CheckMemoryLeakInFunction::findleak(tokens);

settings0.debug = settings0.debugwarnings = false;

return (tok ? tok->linenr() : (unsigned int)(-1));

}

void findleak() {

static const unsigned int notfound = (unsigned int)(-1);

ASSERT_EQUALS(1, dofindleak("alloc;"));

ASSERT_EQUALS(1, dofindleak("; use; { alloc; }"));

ASSERT_EQUALS(2, dofindleak("alloc;\n return;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; return use;"));

ASSERT_EQUALS(2, dofindleak("alloc;\n callfunc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; use;"));

ASSERT_EQUALS(notfound, dofindleak("assign; alloc; dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("assign; if alloc; dealloc;"));

// if alloc..

ASSERT_EQUALS(2, dofindleak("if alloc;\n return;"));

ASSERT_EQUALS(notfound, dofindleak("if alloc;\n return use;"));

ASSERT_EQUALS(notfound, dofindleak("if alloc;\n use;"));

ASSERT_EQUALS(notfound, dofindleak("if alloc;\n if assign;\n if dealloc; }"));

// if..

ASSERT_EQUALS(notfound, dofindleak("alloc; ifv dealloc;"));

ASSERT_EQUALS(2, dofindleak("alloc;\n if return;\n dealloc;"));

ASSERT_EQUALS(2, dofindleak("alloc;\n if continue;\n dealloc;"));

ASSERT_EQUALS(2, dofindleak("alloc;\n if_var return;\n dealloc;"));

ASSERT_EQUALS(3, dofindleak("alloc;\n if\n return;\n dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; if { dealloc ; return; } dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; if { dealloc ; return; } dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; if { dealloc ; alloc; } dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc;\n if(!var)\n { callfunc;\n return;\n }\n use;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; if { return use; } dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc; if { dealloc; return; } dealloc;"));

ASSERT_EQUALS(5, dofindleak("{\n;\n alloc;\n if dealloc;\n}"));

// assign..

ASSERT_EQUALS(2, dofindleak("alloc;\n assign;\n dealloc;"));

ASSERT_EQUALS(notfound, dofindleak("alloc;\n if(!var) assign;\n dealloc;"));

ASSERT_EQUALS(2, dofindleak(";alloc;\n if assign;\n dealloc;"));

// loop..

TODO_ASSERT_EQUALS(1, notfound, dofindleak("; loop { alloc ; if break; dealloc ; }"));

TODO_ASSERT_EQUALS(1, notfound, dofindleak("; loop { alloc ; if continue; dealloc ; }"));

ASSERT_EQUALS(notfound, dofindleak("; loop { alloc ; if break; } dealloc ;"));

ASSERT_EQUALS(1, dofindleak("; loop alloc ;"));

ASSERT_EQUALS(1, dofindleak("; loop alloc ; dealloc ;"));

// callfunc (might be noreturn)

ASSERT_EQUALS(notfound, dofindleak("; alloc ; callfunc ; }"));

}

void simple5() {

check("static char *f()\n"

"{\n"

" struct *str = new strlist;\n"

" return &str->s;\n"

"}");

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

}

void simple7() {

// A garbage collector may delete f automatically

check("class Fred;\n"

"void foo()\n"

"{\n"

" Fred *f = new Fred;\n"

"}");

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

}

void simple9() {

check("void foo()\n"

"{\n"

" MyClass *c = new MyClass();\n"

" c->free(c);\n"

" delete c;\n"

"}");

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

}

void simple11() {

check("void Fred::aaa()\n"

"{ }\n"

"\n"

"void Fred::foo()\n"

"{\n"

" char *s = NULL;\n"

" if (a)\n"

" s = malloc(10);\n"

" else if (b)\n"

" s = malloc(10);\n"

" else\n"

" f();\n"

" g(s);\n"

" if (c)\n"

" h(s);\n"

" free(s);\n"

"}");

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

}

void nonstd_free() {

check("void f() {\n"

" void* mem = malloc(100, foo);" // Non-standard malloc() implementation

" free(mem, bar);" // Non-standard free() implementation (#5665)

"}");

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

}

void new_nothrow() {

check("void f()\n"

"{\n"

" int *p = new(std::nothrow) int;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Memory leak: p\n", errout.str());

check("void f()\n"

"{\n"

" using std::nothrow;\n"

" int *p = new(nothrow) int;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: p\n", errout.str());

check("void f()\n"

"{\n"

" int *p = new(std::nothrow) int[10];\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Memory leak: p\n", errout.str());

check("void f()\n"

"{\n"

" using namespace std;\n"

" int *p = new(nothrow) int[10];\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: p\n", errout.str());

check("void f()\n"

"{\n"

" int *p = new(std::nothrow) int;\n"

" delete [] p;\n"

"}");

ASSERT_EQUALS("[test.cpp:4]: (error) Mismatching allocation and deallocation: p\n", errout.str());

check("void f()\n"