TestLeakAutoVar() : TestFixture("TestLeakAutoVar") {}

Settings settings;

void run() OVERRIDE {

int id = 0;

while (!Library::ismemory(++id));

settings.library.setalloc("malloc", id, -1);

settings.library.setrealloc("realloc", id, -1);

settings.library.setdealloc("free", id, 1);

while (!Library::isresource(++id));

settings.library.setalloc("socket", id, -1);

settings.library.setdealloc("close", id, 1);

while (!Library::isresource(++id));

settings.library.setalloc("fopen", id, -1);

settings.library.setrealloc("freopen", id, -1, 3);

settings.library.setdealloc("fclose", id, 1);

settings.library.smartPointers["std::shared_ptr"];

settings.library.smartPointers["std::unique_ptr"];

settings.library.smartPointers["std::unique_ptr"].unique = true;

const char xmldata[] = "<?xml version=\"1.0\"?>\n"

"<def>\n"

" <podtype name=\"uint8_t\" sign=\"u\" size=\"1\"/>\n"

"</def>";

tinyxml2::XMLDocument doc;

doc.Parse(xmldata, sizeof(xmldata));

settings.library.load(doc);

// Assign

TEST_CASE(assign1);

TEST_CASE(assign2);

TEST_CASE(assign3);

TEST_CASE(assign4);

TEST_CASE(assign5);

TEST_CASE(assign6);

TEST_CASE(assign7);

TEST_CASE(assign8);

TEST_CASE(assign9);

TEST_CASE(assign10);

TEST_CASE(assign11); // #3942: x = a(b(p));

TEST_CASE(assign12); // #4236: FP. bar(&x);

TEST_CASE(assign13); // #4237: FP. char*&ref=p; p=malloc(10); free(ref);

TEST_CASE(assign14);

TEST_CASE(assign15);

TEST_CASE(assign16);

TEST_CASE(assign17); // #9047

TEST_CASE(assign18);

TEST_CASE(assign19);

TEST_CASE(assign20); // #9187

TEST_CASE(assign21); // #10186

TEST_CASE(assign22); // #9139

TEST_CASE(isAutoDealloc);

TEST_CASE(realloc1);

TEST_CASE(realloc2);

TEST_CASE(realloc3);

TEST_CASE(realloc4);

TEST_CASE(realloc5); // #9292, #9990

TEST_CASE(freopen1);

TEST_CASE(freopen2);

TEST_CASE(deallocuse1);

TEST_CASE(deallocuse2);

TEST_CASE(deallocuse3);

TEST_CASE(deallocuse4);

TEST_CASE(deallocuse5); // #4018: FP. free(p), p = 0;

TEST_CASE(deallocuse6); // #4034: FP. x = p = f();

TEST_CASE(deallocuse7); // #6467, #6469, #6473

TEST_CASE(deallocuse8); // #1765

TEST_CASE(doublefree1);

TEST_CASE(doublefree2);

TEST_CASE(doublefree3); // #4914

TEST_CASE(doublefree4); // #5451 - FP when exit is called

TEST_CASE(doublefree5); // #5522

TEST_CASE(doublefree6); // #7685

TEST_CASE(doublefree7);

TEST_CASE(doublefree8);

TEST_CASE(doublefree9);

TEST_CASE(doublefree10); // #8706

TEST_CASE(doublefree11);

// exit

TEST_CASE(exit1);

TEST_CASE(exit2);

TEST_CASE(exit3);

// handling function calls

TEST_CASE(functioncall1);

// goto

TEST_CASE(goto1);

TEST_CASE(goto2);

// if/else

TEST_CASE(ifelse1);

TEST_CASE(ifelse2);

TEST_CASE(ifelse3);

TEST_CASE(ifelse4);

TEST_CASE(ifelse5);

TEST_CASE(ifelse6); // #3370

TEST_CASE(ifelse7); // #5576 - if (fd < 0)

TEST_CASE(ifelse8); // #5747 - if (fd == -1)

TEST_CASE(ifelse9); // #5273 - if (X(p==NULL, 0))

TEST_CASE(ifelse10); // #8794 - if (!(x!=NULL))

TEST_CASE(ifelse11); // #8365 - if (NULL == (p = malloc(4)))

TEST_CASE(ifelse12); // #8340 - if ((*p = malloc(4)) == NULL)

TEST_CASE(ifelse13); // #8392

TEST_CASE(ifelse14); // #9130 - if (x == (char*)NULL)

TEST_CASE(ifelse15); // #9206 - if (global_ptr = malloc(1))

TEST_CASE(ifelse16); // #9635 - if (p = malloc(4), p == NULL)

TEST_CASE(ifelse17); // if (!!(!p))

TEST_CASE(ifelse18);

TEST_CASE(ifelse19);

TEST_CASE(ifelse20); // #10182

TEST_CASE(ifelse21);

TEST_CASE(ifelse22); // #10187

// switch

TEST_CASE(switch1);

// loops

TEST_CASE(loop1);

// mismatching allocation/deallocation

TEST_CASE(mismatchAllocDealloc);

TEST_CASE(smartPointerDeleter);

TEST_CASE(smartPointerRelease);

// Execution reaches a 'return'

TEST_CASE(return1);

TEST_CASE(return2);

TEST_CASE(return3);

TEST_CASE(return4);

TEST_CASE(return5);

TEST_CASE(return6); // #8282 return {p, p}

TEST_CASE(return7); // #9343 return (uint8_t*)x

TEST_CASE(return8);

// General tests: variable type, allocation type, etc

TEST_CASE(test1);

TEST_CASE(test2);

TEST_CASE(test3); // #3954 - reference pointer

TEST_CASE(test4); // #5923 - static pointer

TEST_CASE(test5); // unknown type

// Execution reaches a 'throw'

TEST_CASE(throw1);

TEST_CASE(throw2);

// Possible leak => Further configuration is needed for complete analysis

TEST_CASE(configuration1);

TEST_CASE(configuration2);

TEST_CASE(configuration3);

TEST_CASE(configuration4);

TEST_CASE(ptrptr);

TEST_CASE(nestedAllocation);

TEST_CASE(testKeywords); // #6767

TEST_CASE(inlineFunction); // #3989

TEST_CASE(smartPtrInContainer); // #8262

TEST_CASE(functionCallCastConfig); // #9652

}

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

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

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

// Check for leaks..

CheckLeakAutoVar c;

settings.checkLibrary = true;

settings.severity.enable(Severity::information);

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

}

void check(const char code[], Settings & settings_) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings_, this);

std::istringstream istr(code);

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

// Check for leaks..

CheckLeakAutoVar c;

settings_.checkLibrary = true;

settings_.severity.enable(Severity::information);

c.runChecks(&tokenizer, &settings_, this);

}

void assign1() {

check("void f() {\n"

" char *p = malloc(10);\n"

" p = NULL;\n"

" free(p);\n"

"}");

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

}

void assign2() {

check("void f() {\n"

" char *p = malloc(10);\n"

" char *q = p;\n"

" free(q);\n"

"}");

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

}

void assign3() {

check("void f() {\n"

" char *p = malloc(10);\n"

" char *q = p + 1;\n"

" free(q - 1);\n"

"}");

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

}

void assign4() {

check("void f() {\n"

" char *a = malloc(10);\n"

" a += 10;\n"

" free(a - 10);\n"

"}");

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

}

void assign5() {

check("void foo()\n"

"{\n"

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

" list += p;\n"

"}");

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

}

void assign6() { // #2806 - FP when there is redundant assignment

check("void foo() {\n"

" char *p = malloc(10);\n"

" p = strcpy(p,q);\n"

" free(p);\n"

"}");

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

}

void assign7() {

check("void foo(struct str *d) {\n"

" struct str *p = malloc(10);\n"

" d->p = p;\n"

"}");

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

}

void assign8() { // linux list

check("void foo(struct str *d) {\n"

" struct str *p = malloc(10);\n"

" d->p = &p->x;\n"

"}");

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

}

void assign9() {

check("void foo() {\n"

" char *p = x();\n"

" free(p);\n"

" p = NULL;\n"

"}");

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

}

void assign10() {

check("void foo() {\n"

" char *p;\n"

" if (x) { p = malloc(10); }\n"

" if (!x) { p = NULL; }\n"

" free(p);\n"

"}");

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

}

void assign11() { // #3942 - FP for x = a(b(p));

check("void f() {\n"

" char *p = malloc(10);\n"

" x = a(b(p));\n"

"}");

ASSERT_EQUALS("[test.c:4]: (information) --check-library: Function b() should have <use>/<leak-ignore> configuration\n", errout.str());

}

void assign12() { // #4236: FP. bar(&x)

check("void f() {\n"

" char *p = malloc(10);\n"

" free(p);\n"

" bar(&p);\n"

" free(p);\n"

"}");

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

}

void assign13() { // #4237: FP. char *&ref=p; p=malloc(10); free(ref);

check("void f() {\n"

" char *p;\n"

" char * &ref = p;\n"

" p = malloc(10);\n"

" free(ref);\n"

"}");

TODO_ASSERT_EQUALS("", "[test.c:6]: (error) Memory leak: p\n", errout.str());

}

void assign14() {

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

" char *p;\n"

" if (x && (p = malloc(10))) { }"

"}");

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

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

" char *p;\n"

" if (x && (p = new char[10])) { }"

"}", true);

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

}

void assign15() {

// #8120

check("void f() {\n"

" baz *p;\n"

" p = malloc(sizeof *p);\n"

" free(p);\n"

" p = malloc(sizeof *p);\n"

" free(p);\n"

"}");

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

}

void assign16() {

check("void f() {\n"

" char *p = malloc(10);\n"

" free(p);\n"

" if (p=dostuff()) *p = 0;\n"

"}");

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

}

void assign17() { // #9047

check("void f() {\n"

" char *p = (char*)malloc(10);\n"

"}");

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

check("void f() {\n"

" char *p = (char*)(int*)malloc(10);\n"

"}");

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

}

void assign18() {

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

" char *p;\n"

" if (x && (p = (char*)malloc(10))) { }"

"}");

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

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

" char *p;\n"

" if (x && (p = (char*)(int*)malloc(10))) { }"

"}");

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

}

void assign19() {

check("void f() {\n"

" char *p = malloc(10);\n"

" free((void*)p);\n"

"}");

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

}

void assign20() { // #9187

check("void f() {\n"

" char *p = static_cast<int>(malloc(10));\n"

"}", true);

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

}

void assign21() { // #10186

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

" void *p = malloc(10);\n"

" *x = (int*)p;\n"

"}", true);

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

}

void assign22() { // #9139

check("void f(char tempFileName[256]) {\n"

" const int fd = socket(AF_INET, SOCK_PACKET, 0 );\n"

"}", true);

ASSERT_EQUALS("[test.cpp:3]: (error) Resource leak: fd\n", errout.str());

check("void f() {\n"

" const void * const p = malloc(10);\n"

"}", true);

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

}

void isAutoDealloc() {

check("void f() {\n"

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

"}", true);

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

check("void f() {\n"

" Fred *fred = new Fred;"

"}", true);

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

check("void f() {\n"

" std::string *str = new std::string;"

"}", true);

TODO_ASSERT_EQUALS("[test.cpp:2]: (error) Memory leak: str\n", "", errout.str());

check("class TestType {\n" // #9028

"public:\n"

" char ca[12];\n"

"};\n"

"void f() {\n"

" TestType *tt = new TestType();\n"

"}", true);

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

}

void realloc1() {

check("void f() {\n"

" void *p = malloc(10);\n"

" void *q = realloc(p, 20);\n"

" free(q)\n"

"}");

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

}

void realloc2() {

check("void f() {\n"

" void *p = malloc(10);\n"

" void *q = realloc(p, 20);\n"

"}");

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

}

void realloc3() {

check("void f() {\n"

" char *p = malloc(10);\n"

" char *q = (char*) realloc(p, 20);\n"

"}");

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

}

void realloc4() {

check("void f(void *p) {\n"

" void * q = realloc(p, 10);\n"

" if (q == NULL)\n"

" return;\n"

"}");

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

}

void realloc5() {

// #9292

check("void * f(void * ptr, size_t size) {\n"

" void *datap = realloc(ptr, size);\n"

" if (size && !datap)\n"

" free(ptr);\n"

" return datap;\n"

"}");

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

// #9990

check("void f() {\n"

" void * p1 = malloc(10);\n"

" if (!p1)\n"

" return;\n"

" void * p2 = realloc(p1, 42);\n"

" if (!p2) {\n"

" free(p1);\n"

" return;\n"

" }\n"

" free(p2);\n"

"}");

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

}

void freopen1() {

check("void f() {\n"

" void *p = fopen(name,a);\n"

" void *q = freopen(name, b, p);\n"

" fclose(q)\n"

"}");

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

}

void freopen2() {

check("void f() {\n"

" void *p = fopen(name,a);\n"

" void *q = freopen(name, b, p);\n"

"}");

ASSERT_EQUALS("[test.c:4]: (error) Resource leak: q\n", errout.str());

}

void deallocuse1() {

check("void f(char *p) {\n"

" free(p);\n"

" *p = 0;\n"

"}");

ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());

check("void f(char *p) {\n"

" free(p);\n"

" char c = *p;\n"

"}");

ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());

}

void deallocuse2() {

check("void f(char *p) {\n"

" free(p);\n"

" strcpy(a, p);\n"

"}");

TODO_ASSERT_EQUALS("error (free,use)", "[test.c:3]: (information) --check-library: Function strcpy() should have <noreturn> configuration\n", errout.str());

check("void f(char *p) {\n" // #3041 - assigning pointer when it's used

" free(p);\n"

" strcpy(a, p=b());\n"

"}");

TODO_ASSERT_EQUALS("", "[test.c:3]: (information) --check-library: Function strcpy() should have <noreturn> configuration\n", errout.str());

}

void deallocuse3() {

check("void f(struct str *p) {\n"

" free(p);\n"

" p = p->next;\n"

"}");

ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());

}

void deallocuse4() {

check("void f(char *p) {\n"

" free(p);\n"

" return p;\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Returning/dereferencing 'p' after it is deallocated / released\n", errout.str());

check("void f(char *p) {\n"

" if (!p) free(p);\n"

" return p;\n"

"}");

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

check("void f(char *p) {\n"

" if (!p) delete p;\n"

" return p;\n"

"}", true);

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

check("void f(char *p) {\n"

" if (!p) delete [] p;\n"

" return p;\n"

"}", true);

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

check("void f(void* p) {\n"

" if (a) {\n"

" free(p);\n"

" return;\n"

" }\n"

" g(p);\n"

" return;\n"

"}");

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

}

void deallocuse5() { // #4018

check("void f(char *p) {\n"

" free(p), p = 0;\n"

" *p = 0;\n" // <- Make sure pointer info is reset. It is NOT a freed pointer dereference

"}");

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

}

void deallocuse6() { // #4034

check("void f(char *p) {\n"

" free(p);\n"

" x = p = foo();\n" // <- p is not dereferenced

"}");

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

}

void deallocuse7() { // #6467, #6469, #6473, #6648

check("struct Foo { int* ptr; };\n"

"void f(Foo* foo) {\n"

" delete foo->ptr;\n"

" foo->ptr = new Foo;\n"

"}", true);

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

check("struct Foo { int* ptr; };\n"

"void f(Foo* foo) {\n"

" delete foo->ptr;\n"

" x = *foo->ptr;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:4]: (error) Dereferencing 'ptr' after it is deallocated / released\n", errout.str());

check("void parse() {\n"

" struct Buf {\n"

" Buf(uint32_t len) : m_buf(new uint8_t[len]) {}\n"

" ~Buf() { delete[]m_buf; }\n"

" uint8_t *m_buf;\n"

" };\n"

"}", true);

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

check("struct Foo {\n"

" Foo();\n"

" Foo* ptr;\n"

" void func();\n"

"};\n"

"void bar(Foo* foo) {\n"

" delete foo->ptr;\n"

" foo->ptr = new Foo;\n"

" foo->ptr->func();\n"

"}", true);

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

check("void foo(void (*conv)(char**)) {\n"

" char * ptr=(char*)malloc(42);\n"

" free(ptr);\n"

" (*conv)(&ptr);\n"

"}");

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

}

void deallocuse8() { // #1765

check("void f() {\n"

" int *ptr = new int;\n"

" delete(ptr);\n"

" *ptr = 0;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:4]: (error) Dereferencing 'ptr' after it is deallocated / released\n", errout.str());

}

void doublefree1() { // #3895

check("void f(char *p) {\n"

" if (x)\n"

" free(p);\n"

" else\n"

" p = 0;\n"

" free(p);\n"

"}");

ASSERT_EQUALS("[test.c:3] -> [test.c:6]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p) {\n"

" free(p);\n"

" free(p);\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p, char *r) {\n"

" free(p);\n"

" free(r);\n"

"}");

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

check(

"void foo() {\n"

" free(p);\n"

" free(r);\n"

"}");

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

check(

"void foo(char *p) {\n"

" if (x < 3) free(p);\n"

" else { if (x > 9) free(p); }\n"

"}");

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

check(

"void foo(char *p) {\n"

" free(p);\n"

" getNext(&p);\n"

" free(p);\n"

"}");

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

check(

"void foo(char *p) {\n"

" free(p);\n"

" bar();\n"

" free(p);\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p) {\n"

" free(p);\n"

" printf(\"Freed memory at location %x\", p);\n"

" free(p);\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(FILE *p) {\n"

" fclose(p);\n"

" fclose(p);\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Resource handle 'p' freed twice.\n", errout.str());

check(

"void foo(FILE *p, FILE *r) {\n"

" fclose(p);\n"

" fclose(r);\n"

"}");

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

check(

"void foo(FILE *p) {\n"

" if (x < 3) fclose(p);\n"

" else { if (x > 9) fclose(p); }\n"

"}");

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

check(

"void foo(FILE *p) {\n"

" fclose(p);\n"

" gethandle(&p);\n"

" fclose(p);\n"

"}");

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

check(

"void foo(FILE *p) {\n"

" fclose(p);\n"

" gethandle();\n"

" fclose(p);\n"

"}");

ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Resource handle 'p' freed twice.\n", errout.str());

check(

"void foo(Data* p) {\n"

" free(p->a);\n"

" free(p->b);\n"

"}");

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

check(

"void f() {\n"

" char *p; p = malloc(100);\n"

" if (x) {\n"

" free(p);\n"

" exit();\n"

" }\n"

" free(p);\n"

"}");

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

check(

"void f() {\n"

" char *p; p = malloc(100);\n"

" if (x) {\n"

" free(p);\n"

" x = 0;\n"

" }\n"

" free(p);\n"

"}");

ASSERT_EQUALS("[test.c:4] -> [test.c:7]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void f() {\n"

" char *p; p = do_something();\n"

" free(p);\n"

" p = do_something();\n"

" free(p);\n"

"}");

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

check(

"void foo(char *p) {\n"

" delete p;\n"

" delete p;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p, char *r) {\n"

" delete p;\n"

" delete r;\n"

"}", true);

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

check(

"void foo(P p) {\n"

" delete p.x;\n"

" delete p;\n"

"}", true);

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

check(

"void foo(char **p) {\n"

" delete p[0];\n"

" delete p[1];\n"

"}", true);

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

check(

"void foo(char *p) {\n"

" delete p;\n"

" getNext(&p);\n"

" delete p;\n"

"}", true);

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

check(

"void foo(char *p) {\n"

" delete p;\n"

" bar();\n"

" delete p;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p) {\n"

" delete[] p;\n"

" delete[] p;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"void foo(char *p, char *r) {\n"

" delete[] p;\n"

" delete[] r;\n"

"}", true);

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

check(

"void foo(char *p) {\n"

" delete[] p;\n"

" getNext(&p);\n"

" delete[] p;\n"

"}", true);

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

check(

"void foo(char *p) {\n"

" delete[] p;\n"

" bar();\n"

" delete[] p;\n"

"}", true);

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());

check(

"LineMarker::~LineMarker() {\n"

" delete pxpm;\n"

"}\n"

"LineMarker &LineMarker::operator=(const LineMarker &) {\n"

" delete pxpm;\n"

" pxpm = NULL;\n"

" return *this;\n"

"}", true);

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

check(

"void foo()\n"

"{\n"

" int* ptr; ptr = NULL;\n"

" try\n"

" {\n"

" ptr = new int(4);\n"

" }\n"

" catch(...)\n"

" {\n"

" delete ptr;\n"

" throw;\n"

" }\n"

" delete ptr;\n"

"}", true);

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

check(

"int foo()\n"

"{\n"

" int* a; a = new int;\n"

" bool doDelete; doDelete = true;\n"

" if (a != 0)\n"

" {\n"

" doDelete = false;\n"

" delete a;\n"

" }\n"

" if(doDelete)\n"

" delete a;\n"

" return 0;\n"

"}", true);

TODO_ASSERT_EQUALS("", "[test.cpp:8] -> [test.cpp:11]: (error) Memory pointed to by 'a' is freed twice.\n", errout.str());

check(

"void foo(int y)\n"

"{\n"

" char * x; x = NULL;\n"

" while(true) {\n"

" x = new char[100];\n"

" if (y++ > 100)\n"

" break;\n"

" delete[] x;\n"

" }\n"

" delete[] x;\n"

"}", true);

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

check(

"void foo(int y)\n"

"{\n"

" char * x; x = NULL;\n"

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

" x = new char[100];\n"

" delete[] x;\n"

" }\n"

" delete[] x;\n"

"}", true);

TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());

check(

"void foo(int y)\n"

"{\n"

" char * x; x = NULL;\n"

" while (isRunning()) {\n"

" x = new char[100];\n"

" delete[] x;\n"

" }\n"

" delete[] x;\n"

"}", true);

TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());

check(

"void foo(int y)\n"

"{\n"

" char * x; x = NULL;\n"

" while (isRunning()) {\n"

" x = malloc(100);\n"

" free(x);\n"

" }\n"

" free(x);\n"

"}");

TODO_ASSERT_EQUALS("[test.c:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());

check(

"void foo(int y)\n"

"{\n"

" char * x; x = NULL;\n"