/*

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

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

#include "errortypes.h"

#include "fixture.h"

#include "helpers.h"

#include "settings.h"

#include "symboldatabase.h"

#include "token.h"

#include <cstddef>

#include <list>

class TestMemleak : public TestFixture {

public:

TestMemleak() : TestFixture("TestMemleak") {}

private:

void run() override {

TEST_CASE(testFunctionReturnType);

TEST_CASE(open);

}

#define functionReturnType(...) functionReturnType_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

CheckMemoryLeak::AllocType functionReturnType_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settingsDefault, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

const CheckMemoryLeak c(&tokenizer, this, &settingsDefault);

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";

SimpleTokenizer tokenizer(settingsDefault, *this);

ASSERT(tokenizer.tokenize(code));

// there is no allocation

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

const CheckMemoryLeak check(&tokenizer, nullptr, &settingsDefault);

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

}

};

REGISTER_TEST(TestMemleak)

class TestMemleakInFunction : public TestFixture {

public:

TestMemleakInFunction() : TestFixture("TestMemleakInFunction") {}

private:

const Settings settings = settingsBuilder().library("std.cfg").library("posix.cfg").build();

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

template<size_t size>

void check_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check for memory leaks..

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

checkMemoryLeak.checkReallocUsage();

}

void run() override {

mNewTemplate = true;

TEST_CASE(realloc1);

TEST_CASE(realloc2);

TEST_CASE(realloc3);

TEST_CASE(realloc4);

TEST_CASE(realloc5);

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

TEST_CASE(realloc18);

TEST_CASE(realloc19);

TEST_CASE(realloc20);

TEST_CASE(realloc21);

TEST_CASE(realloc22);

TEST_CASE(realloc23);

TEST_CASE(realloc24); // #9228

}

void realloc1() {

check("void foo()\n"

"{\n"

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

" a = realloc(a, 100);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc2() {

check("void foo()\n"

"{\n"

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

" a = (char *)realloc(a, 100);\n"

" free(a);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc3() {

check("void foo()\n"

"{\n"

" char *a = 0;\n"

" if ((a = realloc(a, 100)) == NULL)\n"

" return;\n"

" free(a);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc4() {

check("void foo()\n"

"{\n"

" static char *a = 0;\n"

" if ((a = realloc(a, 100)) == NULL)\n"

" return;\n"

" free(a);\n"

"}");

TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: a\n",

"[test.cpp:4:10]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n",

errout_str());

}

void realloc5() {

check("void foo()\n"

"{\n"

" char *buf;\n"

" char *new_buf;\n"

" buf = calloc( 10 );\n"

" new_buf = realloc ( buf, 20);\n"

" if ( !new_buf )\n"

" free(buf);\n"

" else\n"

" free(new_buf);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc7() {

check("bool foo(size_t nLen, char* pData)\n"

"{\n"

" pData = (char*) realloc(pData, sizeof(char) + (nLen + 1)*sizeof(char));\n"

" if ( pData == NULL )\n"

" {\n"

" return false;\n"

" }\n"

" free(pData);\n"

" return true;\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc8() {

check("void foo()\n"

"{\n"

" char *origBuf = m_buf;\n"

" m_buf = (char *) realloc (m_buf, m_capacity + growBy);\n"

" if (!m_buf) {\n"

" m_buf = origBuf;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc9() {

check("void foo()\n"

"{\n"

" x = realloc(x,100);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc10() {

check("void foo() {\n"

" char *pa, *pb;\n"

" pa = pb = malloc(10);\n"

" pa = realloc(pa, 20);"

" exit();\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc11() {

check("void foo() {\n"

" char *p;\n"

" p = realloc(p, size);\n"

" if (!p)\n"

" error();\n"

" usep(p);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc12() {

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

"{\n"

" char *a = 0;\n"

" if ((a = realloc(a, x + 100)) == NULL)\n"

" return;\n"

" free(a);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc13() {

check("void foo()\n"

"{\n"

" char **str;\n"

" *str = realloc(*str,100);\n"

" free (*str);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:6]: (error) Common realloc mistake: \'str\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc14() {

check("void foo() {\n"

" char *p;\n"

" p = realloc(p, size + 1);\n"

" if (!p)\n"

" error();\n"

" usep(p);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc15() {

check("bool foo() {\n"

" char ** m_options;\n"

" m_options = (char**)realloc( m_options, 2 * sizeof(char*));\n"

" if( m_options == NULL )\n"

" return false;\n"

" return true;\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Common realloc mistake: \'m_options\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc16() {

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

" zLine = realloc(zLine, 42);\n"

" if (zLine) {\n"

" free(zLine);\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc17() {

check("void foo()\n"

"{\n"

" void ***a = malloc(sizeof(a));\n"

" ***a = realloc(***(a), sizeof(a) * 2);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:8]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc18() {

check("void foo()\n"

"{\n"

" void *a = malloc(sizeof(a));\n"

" a = realloc((void*)a, sizeof(a) * 2);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc19() {

check("void foo()\n"

"{\n"

" void *a = malloc(sizeof(a));\n"

" a = (realloc((void*)((a)), sizeof(a) * 2));\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

}

void realloc20() {

check("void foo()\n"

"{\n"

" void *a = malloc(sizeof(a));\n"

" a = realloc((a) + 1, sizeof(a) * 2);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc21() {

check("char *foo(char *bs0)\n"

"{\n"

" char *bs = bs0;\n"

" bs = realloc(bs, 100);\n"

" if (bs == NULL) return bs0;\n"

" return bs;\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc22() {

check("void foo(char **bsp)\n"

"{\n"

" char *bs = *bsp;\n"

" bs = realloc(bs, 100);\n"

" if (bs == NULL) return;\n"

" *bsp = bs;\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc23() {

check("void foo(struct ABC *s)\n"

"{\n"

" uint32_t *cigar = s->cigar;\n"

" if (!(cigar = realloc(cigar, 100 * sizeof(*cigar))))\n"

" return;\n"

" s->cigar = cigar;\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void realloc24() { // #9228

check("void f() {\n"

"void *a = NULL;\n"

"a = realloc(a, 20);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void f() {\n"

"void *a = NULL;\n"

"a = malloc(10);\n"

"a = realloc(a, 20);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

check("void f() {\n"

"void *a = nullptr;\n"

"a = malloc(10);\n"

"a = realloc(a, 20);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());

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

"void *a = NULL;\n"

"a = b;\n"

"a = realloc(a, 20);\n"

"}");

ASSERT_EQUALS("", errout_str());

}

};

REGISTER_TEST(TestMemleakInFunction)

class TestMemleakInClass : public TestFixture {

public:

TestMemleakInClass() : TestFixture("TestMemleakInClass") {}

private:

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

/**

* Tokenize and execute leak check for given code

* @param code Source code

*/

template<size_t size>

void check_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check for memory leaks..

CheckMemoryLeakInClass checkMemoryLeak(&tokenizer, &settings, this);

(checkMemoryLeak.check)();

}

void run() override {

mNewTemplate = true;

TEST_CASE(class1);

TEST_CASE(class2);

TEST_CASE(class3);

TEST_CASE(class4);

TEST_CASE(class6);

TEST_CASE(class7);

TEST_CASE(class8);

TEST_CASE(class9);

TEST_CASE(class10);

TEST_CASE(class11);

TEST_CASE(class12);

TEST_CASE(class13);

TEST_CASE(class14);

TEST_CASE(class15);

TEST_CASE(class16);

TEST_CASE(class17);

TEST_CASE(class18);

TEST_CASE(class19); // ticket #2219

TEST_CASE(class20);

TEST_CASE(class21); // ticket #2517

TEST_CASE(class22); // ticket #3012

TEST_CASE(class23); // ticket #3303

TEST_CASE(class24); // ticket #3806 - false positive in copy constructor

TEST_CASE(class25); // ticket #4367 - false positive implementation for destructor is not seen

TEST_CASE(class26); // ticket #10789

TEST_CASE(class27); // ticket #8126

TEST_CASE(staticvar);

TEST_CASE(free_member_in_sub_func);

TEST_CASE(mismatch1);

TEST_CASE(mismatch2); // #5659

// allocating member variable in public function

TEST_CASE(func1);

TEST_CASE(func2);

}

void class1() {

check("class Fred\n"

"{\n"

"private:\n"

" char *str1;\n"

" char *str2;\n"

"public:\n"

" Fred();\n"

" ~Fred();\n"

"};\n"

"\n"

"Fred::Fred()\n"

"{\n"

" str1 = new char[10];\n"

" str2 = new char[10];\n"

"}\n"

"\n"

"Fred::~Fred()\n"

"{\n"

" delete [] str2;\n"

"}");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class Fred\n"

"{\n"

"private:\n"

" char *str1;\n"

" char *str2;\n"

"public:\n"

" Fred()\n"

" {\n"

" str1 = new char[10];\n"

" str2 = new char[10];\n"

" }\n"

" ~Fred()\n"

" {\n"

" delete [] str2;\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

}

void class2() {

check("class Fred\n"

"{\n"

"private:\n"

" char *str1;\n"

"public:\n"

" Fred();\n"

" ~Fred();\n"

"};\n"

"\n"

"Fred::Fred()\n"

"{\n"

" str1 = new char[10];\n"

"}\n"

"\n"

"Fred::~Fred()\n"

"{\n"

" free(str1);\n"

"}");

ASSERT_EQUALS("[test.cpp:17:5]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());

check("class Fred\n"

"{\n"

"private:\n"

" char *str1;\n"

"public:\n"

" Fred()\n"

" {\n"

" str1 = new char[10];\n"

" }\n"

" ~Fred()\n"

" {\n"

" free(str1);\n"

" }\n"

"};");

ASSERT_EQUALS("[test.cpp:12:9]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());

}

void class3() {

check("class Token;\n"

"\n"

"class Tokenizer\n"

"{\n"

"private:\n"

" Token *_tokens;\n"

"\n"

"public:\n"

" Tokenizer();\n"

" ~Tokenizer();\n"

" void deleteTokens(Token *tok);\n"

"};\n"

"\n"

"Tokenizer::Tokenizer()\n"

"{\n"

" _tokens = new Token;\n"

"}\n"

"\n"

"Tokenizer::~Tokenizer()\n"

"{\n"

" deleteTokens(_tokens);\n"

"}\n"

"\n"

"void Tokenizer::deleteTokens(Token *tok)\n"

"{\n"

" while (tok)\n"

" {\n"

" Token *next = tok->next();\n"

" delete tok;\n"

" tok = next;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class Token;\n"

"\n"

"class Tokenizer\n"

"{\n"

"private:\n"

" Token *_tokens;\n"

"\n"

"public:\n"

" Tokenizer()\n"

" {\n"

" _tokens = new Token;\n"

" }\n"

" ~Tokenizer()\n"

" {\n"

" deleteTokens(_tokens);\n"

" }\n"

" void deleteTokens(Token *tok)\n"

" {\n"

" while (tok)\n"

" {\n"

" Token *next = tok->next();\n"

" delete tok;\n"

" tok = next;\n"

" }\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class4() {

check("struct ABC;\n"

"class Fred\n"

"{\n"

"private:\n"

" void addAbc(ABC *abc);\n"

"public:\n"

" void click();\n"

"};\n"

"\n"

"void Fred::addAbc(ABC* abc)\n"

"{\n"

" AbcPosts->Add(abc);\n"

"}\n"

"\n"

"void Fred::click()\n"

"{\n"

" ABC *p = new ABC;\n"

" addAbc( p );\n"

"}");

ASSERT_EQUALS("", errout_str());

check("struct ABC;\n"

"class Fred\n"

"{\n"

"private:\n"

" void addAbc(ABC* abc)\n"

" {\n"

" AbcPosts->Add(abc);\n"

" }\n"

"public:\n"

" void click()\n"

" {\n"

" ABC *p = new ABC;\n"

" addAbc( p );\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class6() {

check("class Fred\n"

"{\n"

"public:\n"

" void foo();\n"

"};\n"

"\n"

"void Fred::foo()\n"

"{\n"

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

" delete [] str;\n"

" hello();\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class Fred\n"

"{\n"

"public:\n"

" void foo()\n"

" {\n"

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

" delete [] str;\n"

" hello();\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class7() {

check("class Fred\n"

"{\n"

"public:\n"

" int *i;\n"

" Fred();\n"

" ~Fred();\n"

"};\n"

"\n"

"Fred::Fred()\n"

"{\n"

" this->i = new int;\n"

"}\n"

"Fred::~Fred()\n"

"{\n"

" delete this->i;\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class Fred\n"

"{\n"

"public:\n"

" int *i;\n"

" Fred()\n"

" {\n"

" this->i = new int;\n"

" }\n"

" ~Fred()\n"

" {\n"

" delete this->i;\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class8() {

check("class A\n"

"{\n"

"public:\n"

" void a();\n"

" void doNothing() { }\n"

"};\n"

"\n"

"void A::a()\n"

"{\n"

" int* c = new int(1);\n"

" delete c;\n"

" doNothing(c);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class A\n"

"{\n"

"public:\n"

" void a()\n"

" {\n"

" int* c = new int(1);\n"

" delete c;\n"

" doNothing(c);\n"

" }\n"

" void doNothing() { }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class9() {

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A();\n"

" ~A();\n"

"};\n"

"\n"

"A::A()\n"

"{ p = new int; }\n"

"\n"

"A::~A()\n"

"{ delete (p); }");

ASSERT_EQUALS("", errout_str());

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A()\n"

" { p = new int; }\n"

" ~A()\n"

" { delete (p); }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void class10() {

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A();\n"

"};\n"

"A::A()\n"

"{ p = new int; }");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A() { p = new int; }\n"

"};");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

}

void class11() {

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A() : p(new int[10])\n"

" { }"

"};");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

"public:\n"

" int * p;\n"

" A();\n"

"};\n"

"A::A() : p(new int[10])\n"

"{ }");

ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

}

void class12() {

check("class A\n"

"{\n"

"private:\n"

" int *p;\n"

"public:\n"

" A();\n"

" ~A();\n"

" void cleanup();"

"};\n"

"\n"

"A::A()\n"

"{ p = new int[10]; }\n"

"\n"

"A::~A()\n"

"{ }\n"

"\n"

"void A::cleanup()\n"

"{ delete [] p; }");

ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

"private:\n"

" int *p;\n"

"public:\n"

" A()\n"

" { p = new int[10]; }\n"

" ~A()\n"

" { }\n"

" void cleanup()\n"

" { delete [] p; }\n"

"};");

ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

}

void class13() {

check("class A\n"

"{\n"

"private:\n"

" int *p;\n"

"public:\n"

" A();\n"

" ~A();\n"

" void foo();"

"};\n"

"\n"

"A::A()\n"

"{ }\n"

"\n"

"A::~A()\n"

"{ }\n"

"\n"

"void A::foo()\n"

"{ p = new int[10]; delete [] p; }");

ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());

check("class A\n"

"{\n"

"private:\n"

" int *p;\n"

"public:\n"

" A()\n"

" { }\n"

" ~A()\n"

" { }\n"

" void foo()\n"

" { p = new int[10]; delete [] p; }\n"

"};");

ASSERT_EQUALS("[test.cpp:11:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());

}

void class14() {

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init();\n"

"};\n"

"\n"

"void A::init()\n"

"{ p = new int[10]; }");

ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init()\n"

" { p = new int[10]; }\n"

"};");

ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init();\n"

"};\n"

"\n"

"void A::init()\n"

"{ p = new int; }");

ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init()\n"

" { p = new int; }\n"

"};");

ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init();\n"

"};\n"

"\n"

"void A::init()\n"

"{ p = malloc(sizeof(int)*10); }");

ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" void init()\n"

" { p = malloc(sizeof(int)*10); }\n"

"};");

ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"

"[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());

}

void class15() {

check("class A\n"

"{\n"

" int *p;\n"

"public:\n"

" A();\n"

" ~A() { delete [] p; }\n"

"};\n"

"A::A()\n"

"{ p = new int[10]; }");

ASSERT_EQUALS("", errout_str());

check("class A\n"

"{\n"

" int *p;\n"