testing: Added tests TestMemoryleak::ifelse
This commit is contained in:
Daniel Marjamäki
parent
61242571dd
commit
794cdfd2ee
|
|
@ -147,360 +147,6 @@ static void MemoryLeak( const TOKEN *tok, const char varname[] )
|
||||||
}
|
}
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
||||||
static void CheckMemoryLeak_CheckScope_All( const TOKEN *Tok1, const char varname[] )
|
|
||||||
{
|
|
||||||
const char *varnames[2];
|
|
||||||
varnames[0] = varname;
|
|
||||||
varnames[1] = 0;
|
|
||||||
|
|
||||||
AllocType Alloc = No;
|
|
||||||
|
|
||||||
int alloc_indentlevel = -1;
|
|
||||||
int dealloc_indentlevel = -1;
|
|
||||||
std::list<int> loop_indentlevel;
|
|
||||||
std::list<int> switch_indentlevel;
|
|
||||||
|
|
||||||
bool isif = false;
|
|
||||||
|
|
||||||
int indentlevel = 0;
|
|
||||||
for (const TOKEN *tok = Tok1 ; tok; tok = tok->next )
|
|
||||||
{
|
|
||||||
if (tok->str[0]=='{')
|
|
||||||
indentlevel++;
|
|
||||||
|
|
||||||
else if (tok->str[0]=='}')
|
|
||||||
{
|
|
||||||
indentlevel--;
|
|
||||||
if ( indentlevel < 0 )
|
|
||||||
{
|
|
||||||
if ( Alloc != No )
|
|
||||||
MemoryLeak( tok, varname );
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( !loop_indentlevel.empty() && indentlevel <= loop_indentlevel.back() )
|
|
||||||
loop_indentlevel.pop_back();
|
|
||||||
|
|
||||||
if ( !switch_indentlevel.empty() && indentlevel <= switch_indentlevel.back() )
|
|
||||||
switch_indentlevel.pop_back();
|
|
||||||
|
|
||||||
if ( indentlevel < alloc_indentlevel )
|
|
||||||
alloc_indentlevel = -1;
|
|
||||||
|
|
||||||
if ( indentlevel < dealloc_indentlevel )
|
|
||||||
dealloc_indentlevel = -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( Alloc != No && Match(tok, ". %var% (") )
|
|
||||||
{
|
|
||||||
bool isused = false;
|
|
||||||
while (tok && !Match(tok, "[;{]"))
|
|
||||||
{
|
|
||||||
if ( Match(tok, "[(,] %var1% [,)]", varnames) )
|
|
||||||
isused = true;
|
|
||||||
tok = tok->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Don't know what happens, assume that it's deallocated.
|
|
||||||
if ( isused )
|
|
||||||
{
|
|
||||||
if ( indentlevel == 0 )
|
|
||||||
return;
|
|
||||||
|
|
||||||
dealloc_indentlevel = indentlevel;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check subfunction...
|
|
||||||
if (Alloc != No && Match(tok,"[{};] %var% ("))
|
|
||||||
{
|
|
||||||
AllocType dealloc = GetDeallocationType(tok->next, varnames);
|
|
||||||
|
|
||||||
const char *funcname = getstr( tok, 1 );
|
|
||||||
if (dealloc==No && strcmp(funcname,"if") && strcmp(funcname,"for") && strcmp(funcname,"while"))
|
|
||||||
{
|
|
||||||
unsigned int param = 0;
|
|
||||||
for (const TOKEN *tok2 = gettok(tok,2); tok2; tok2 = tok2->next)
|
|
||||||
{
|
|
||||||
if ( tok2->str[0] == ';' || tok2->str[0] == ')' )
|
|
||||||
break;
|
|
||||||
if ( tok2->str[0] == ',' )
|
|
||||||
param++;
|
|
||||||
|
|
||||||
if ( Match(tok2, "[(,] %var1% [,)]", varnames) )
|
|
||||||
{
|
|
||||||
// Find function..
|
|
||||||
const TOKEN *ftok = GetFunctionTokenByName( funcname );
|
|
||||||
ftok = gettok(ftok,2);
|
|
||||||
if ( ! ftok )
|
|
||||||
{
|
|
||||||
// Can't find the function but to avoid false
|
|
||||||
// positives it is assumed that the variable is
|
|
||||||
// deallocated..
|
|
||||||
|
|
||||||
// Deallocated at same indentlevel as the allocation => no memory leak
|
|
||||||
if ( alloc_indentlevel == indentlevel )
|
|
||||||
return;
|
|
||||||
|
|
||||||
dealloc_indentlevel = indentlevel;
|
|
||||||
}
|
|
||||||
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// Goto function parameter..
|
|
||||||
for ( unsigned int fparam = 0; ftok && fparam < param; ftok = ftok->next )
|
|
||||||
{
|
|
||||||
if ( ftok->str[0] == ',' )
|
|
||||||
++fparam;
|
|
||||||
}
|
|
||||||
for ( ; ftok; ftok = ftok->next )
|
|
||||||
{
|
|
||||||
if ( ! Match(ftok,"%var% [,)]") )
|
|
||||||
continue;
|
|
||||||
|
|
||||||
const char *paramname[2] = {0};
|
|
||||||
paramname[0] = ftok->str;
|
|
||||||
// parse function and check if it deallocates the parameter..
|
|
||||||
int _indentlevel = 0;
|
|
||||||
while (_indentlevel>=0 && ftok)
|
|
||||||
{
|
|
||||||
if ( ftok->str[0] == '{' )
|
|
||||||
_indentlevel++;
|
|
||||||
else if ( ftok->str[0] == '}' )
|
|
||||||
{
|
|
||||||
_indentlevel--;
|
|
||||||
if ( _indentlevel <= 0 )
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( _indentlevel >= 1 )
|
|
||||||
{
|
|
||||||
AllocType dealloc = GetDeallocationType(ftok,paramname);
|
|
||||||
if ( dealloc != No )
|
|
||||||
{
|
|
||||||
if ( Alloc != No && Alloc != dealloc )
|
|
||||||
{
|
|
||||||
MismatchError( Tok1, varname );
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Deallocated at same indentlevel as the allocation => no memory leak
|
|
||||||
if ( alloc_indentlevel == indentlevel )
|
|
||||||
return;
|
|
||||||
|
|
||||||
dealloc_indentlevel = indentlevel;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ftok = ftok->next;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// for, while set loop level..
|
|
||||||
if ( Match(tok,"while") || Match(tok,"for") )
|
|
||||||
loop_indentlevel.push_back( indentlevel );
|
|
||||||
|
|
||||||
// switch..
|
|
||||||
if (Match(tok,"switch"))
|
|
||||||
switch_indentlevel.push_back( indentlevel );
|
|
||||||
|
|
||||||
// Skip stuff like: if (!var) ...
|
|
||||||
if ( Match(tok, "if ( ! %var1% )", varnames) ||
|
|
||||||
Match(tok, "if ( unlikely ( ! %var1% ) )", varnames) ||
|
|
||||||
Match(tok, "if ( %var1% == NULL )", varnames) ||
|
|
||||||
Match(tok, "if ( NULL == %var1% )", varnames) ||
|
|
||||||
Match(tok, "if ( %var1% == 0 )", varnames) )
|
|
||||||
{
|
|
||||||
int _indentlevel = 0;
|
|
||||||
while ( tok )
|
|
||||||
{
|
|
||||||
if ( tok->str[0] == '{' )
|
|
||||||
_indentlevel++;
|
|
||||||
else if ( tok->str[0] == '}' )
|
|
||||||
{
|
|
||||||
_indentlevel--;
|
|
||||||
if ( _indentlevel <= 0 )
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
else if (_indentlevel==0 && tok->str[0]==';')
|
|
||||||
break;
|
|
||||||
tok = tok->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// if..
|
|
||||||
if ( Match(tok,"if") )
|
|
||||||
isif = true;
|
|
||||||
if ( strchr(";{}", tok->str[0]) )
|
|
||||||
isif = false;
|
|
||||||
|
|
||||||
// Allocated..
|
|
||||||
if ( Match(tok, "[(;{}] %var1% =", varnames) )
|
|
||||||
{
|
|
||||||
AllocType alloc = GetAllocationType( gettok(tok, 3) );
|
|
||||||
if ( alloc != No )
|
|
||||||
{
|
|
||||||
tok = tok->next;
|
|
||||||
Alloc = alloc;
|
|
||||||
alloc_indentlevel = indentlevel;
|
|
||||||
|
|
||||||
if ( isif )
|
|
||||||
{
|
|
||||||
while ( tok )
|
|
||||||
{
|
|
||||||
if ( tok->str[0] == '{' )
|
|
||||||
{
|
|
||||||
indentlevel++;
|
|
||||||
}
|
|
||||||
else if ( tok->str[0] == '}' )
|
|
||||||
{
|
|
||||||
indentlevel--;
|
|
||||||
if ( indentlevel <= alloc_indentlevel )
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
else if ( tok->str[0] == ';' && indentlevel == alloc_indentlevel )
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
tok = tok->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Deallocated..
|
|
||||||
AllocType dealloc = GetDeallocationType( tok, varnames );
|
|
||||||
if ( dealloc != No )
|
|
||||||
{
|
|
||||||
if ( Alloc != No && Alloc != dealloc )
|
|
||||||
{
|
|
||||||
MismatchError( tok, varname );
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Deallocated at same indentlevel as the allocation => no memory leak
|
|
||||||
if ( alloc_indentlevel == indentlevel )
|
|
||||||
return;
|
|
||||||
|
|
||||||
dealloc_indentlevel = indentlevel;
|
|
||||||
while ( tok && tok->str[0] != ';' )
|
|
||||||
tok = tok->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used..
|
|
||||||
// list.push_back( var1 );
|
|
||||||
// listtail->next = var1;
|
|
||||||
if ( Match( tok, "[=] %var1% [;]", varnames ) )
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if ( Match( tok, "[=,(] ( %type% * ) %var1% [,);]", varnames ) )
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if ( Match( tok, "[=,(] ( %type% %type% * ) %var1% [,);]", varnames ) )
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used. Todo: check if "p" is the first member in the struct.
|
|
||||||
// p = &var1->p;
|
|
||||||
if ( Match( tok, "= & %var1% . %var% ;", varnames ) )
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Linux lists.. todo: check if the first struct member is passed
|
|
||||||
if ( Match( tok, "%var% ( & %var1% .", varnames ) ||
|
|
||||||
Match( tok, ", & %var1% .", varnames ) )
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// continue/break loop..
|
|
||||||
if (Alloc != No &&
|
|
||||||
loop_indentlevel.empty() &&
|
|
||||||
switch_indentlevel.empty() &&
|
|
||||||
(Match(tok,"continue") || Match(tok,"break")))
|
|
||||||
{
|
|
||||||
MemoryLeak( tok, varname );
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return without deallocating the memory..
|
|
||||||
if ( Alloc != No && (indentlevel==0 || (alloc_indentlevel >= 0 && dealloc_indentlevel <= 0)) && Match(tok, "return") )
|
|
||||||
{
|
|
||||||
bool retvar = false;
|
|
||||||
for ( const TOKEN *tok2 = tok->next; tok2; tok2 = tok2->next )
|
|
||||||
{
|
|
||||||
if ( Match( tok2, "%var1%", varnames ) )
|
|
||||||
{
|
|
||||||
retvar = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( tok2->str[0] == ';' )
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( ! retvar )
|
|
||||||
MemoryLeak( tok, varname );
|
|
||||||
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// The allocated memory is returned.. check that it is deallocated
|
|
||||||
|
|
||||||
// Get function name..
|
|
||||||
const char *funcname = 0;
|
|
||||||
int indentlevel = 0;
|
|
||||||
for ( const TOKEN *ftok = tokens; ftok && ftok != tok; ftok = ftok->next )
|
|
||||||
{
|
|
||||||
if ( ftok->str[0] == '{' )
|
|
||||||
indentlevel++;
|
|
||||||
|
|
||||||
else if ( ftok->str[0] == '}' )
|
|
||||||
indentlevel--;
|
|
||||||
|
|
||||||
if ( indentlevel <= 0 )
|
|
||||||
{
|
|
||||||
if ( Match(ftok, "[};]") )
|
|
||||||
funcname = 0;
|
|
||||||
else if ( Match(ftok, "%var% (") )
|
|
||||||
funcname = ftok->str;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( funcname )
|
|
||||||
{
|
|
||||||
listallocfunc.push_back( AllocFunc(funcname, Alloc) );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( indentlevel == 0 )
|
|
||||||
return;
|
|
||||||
|
|
||||||
if ( indentlevel <= alloc_indentlevel )
|
|
||||||
{
|
|
||||||
Alloc = No;
|
|
||||||
alloc_indentlevel = -1;
|
|
||||||
dealloc_indentlevel = -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
extern bool ShowAll;
|
extern bool ShowAll;
|
||||||
|
|
||||||
static TOKEN *getcode(const TOKEN *tok, const char varname[])
|
static TOKEN *getcode(const TOKEN *tok, const char varname[])
|
||||||
|
|
@ -670,12 +316,6 @@ static void erase(TOKEN *begin, const TOKEN *end)
|
||||||
// Simpler but less powerful than "CheckMemoryLeak_CheckScope_All"
|
// Simpler but less powerful than "CheckMemoryLeak_CheckScope_All"
|
||||||
static void CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const char varname[] )
|
static void CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const char varname[] )
|
||||||
{
|
{
|
||||||
if ( ShowAll )
|
|
||||||
{
|
|
||||||
CheckMemoryLeak_CheckScope_All(Tok1, varname);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
TOKEN *tok = getcode( Tok1, varname );
|
TOKEN *tok = getcode( Tok1, varname );
|
||||||
|
|
||||||
// If the variable is not allocated at all => no memory leak
|
// If the variable is not allocated at all => no memory leak
|
||||||
|
|
@ -755,6 +395,15 @@ static void CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const char varname[]
|
||||||
done = false;
|
done = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Replace "if { dealloc ; return ; }" with "if ;"
|
||||||
|
if (Match(tok2,"if { dealloc ; return ; }"))
|
||||||
|
{
|
||||||
|
erase(tok2, gettok(tok2, 6));
|
||||||
|
free(tok2->next->str);
|
||||||
|
tok2->next->str = strdup(";");
|
||||||
|
done = false;
|
||||||
|
}
|
||||||
|
|
||||||
// "[;{}] if alloc ; else return ;" => "[;{}] alloc ;"
|
// "[;{}] if alloc ; else return ;" => "[;{}] alloc ;"
|
||||||
if (Match(tok2,"[;{}] if alloc ; else return ;"))
|
if (Match(tok2,"[;{}] if alloc ; else return ;"))
|
||||||
{
|
{
|
||||||
|
|
@ -763,6 +412,13 @@ static void CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const char varname[]
|
||||||
done = false;
|
done = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Replace "dealloc use ;" with "dealloc ;"
|
||||||
|
if ( Match(tok2, "dealloc use ;") )
|
||||||
|
{
|
||||||
|
erase(tok2, gettok(tok2,2));
|
||||||
|
done = false;
|
||||||
|
}
|
||||||
|
|
||||||
// Delete "loop ;"
|
// Delete "loop ;"
|
||||||
if ( Match(tok2->next, "loop ;") )
|
if ( Match(tok2->next, "loop ;") )
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -226,7 +226,7 @@ void Assert::assertEquals( const std::string expected, const std::string result,
|
||||||
|
|
||||||
int indexDiferent = notEqualIndex(expected, result);
|
int indexDiferent = notEqualIndex(expected, result);
|
||||||
TestsListener::theInstance().errorsLog()
|
TestsListener::theInstance().errorsLog()
|
||||||
<< file << ", linia: " << linia << "\n"
|
<< file << ", line: " << linia << "\n"
|
||||||
<< errmsgTag_expected() << "\n" << blue()
|
<< errmsgTag_expected() << "\n" << blue()
|
||||||
<< expected.substr(0,indexDiferent)
|
<< expected.substr(0,indexDiferent)
|
||||||
<< green() << expected.substr(indexDiferent)
|
<< green() << expected.substr(indexDiferent)
|
||||||
|
|
|
||||||
207
testmemleak.cpp
207
testmemleak.cpp
|
|
@ -6,6 +6,7 @@
|
||||||
#include <sstream>
|
#include <sstream>
|
||||||
|
|
||||||
extern std::ostringstream errout;
|
extern std::ostringstream errout;
|
||||||
|
extern bool ShowAll;
|
||||||
|
|
||||||
class TestMemleak : public TestFixture<TestMemleak>
|
class TestMemleak : public TestFixture<TestMemleak>
|
||||||
{
|
{
|
||||||
|
|
@ -22,6 +23,7 @@ private:
|
||||||
errout.str("");
|
errout.str("");
|
||||||
|
|
||||||
// Check for memory leaks..
|
// Check for memory leaks..
|
||||||
|
ShowAll = false;
|
||||||
CheckMemoryLeak();
|
CheckMemoryLeak();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -29,6 +31,18 @@ public:
|
||||||
TEST_FIXTURE( TestMemleak )
|
TEST_FIXTURE( TestMemleak )
|
||||||
{
|
{
|
||||||
TEST_CASE( simple1 );
|
TEST_CASE( simple1 );
|
||||||
|
TEST_CASE( simple2 );
|
||||||
|
TEST_CASE( simple3 );
|
||||||
|
TEST_CASE( simple4 );
|
||||||
|
TEST_CASE( simple5 );
|
||||||
|
TEST_CASE( simple6 );
|
||||||
|
TEST_CASE( simple7 );
|
||||||
|
|
||||||
|
TEST_CASE( ifelse1 );
|
||||||
|
TEST_CASE( ifelse2 );
|
||||||
|
TEST_CASE( ifelse3 );
|
||||||
|
TEST_CASE( ifelse4 );
|
||||||
|
TEST_CASE( ifelse5 );
|
||||||
}
|
}
|
||||||
|
|
||||||
void simple1()
|
void simple1()
|
||||||
|
|
@ -39,6 +53,199 @@ public:
|
||||||
"}\n" );
|
"}\n" );
|
||||||
ASSERT_EQUALS( std::string("[test.cpp:4]: Memory leak: a\n"), errout.str() );
|
ASSERT_EQUALS( std::string("[test.cpp:4]: Memory leak: a\n"), errout.str() );
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void simple2()
|
||||||
|
{
|
||||||
|
check( "Fred *NewFred()\n"
|
||||||
|
"{\n"
|
||||||
|
" Fred *f = new Fred;\n"
|
||||||
|
" return f;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
void simple3()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *s = new char[100];\n"
|
||||||
|
" return (char *)s;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void simple4()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *s = new char[100];\n"
|
||||||
|
" return 0;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string("[test.cpp:4]: Memory leak: s\n"), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void simple5()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" struct *str = new strlist;\n"
|
||||||
|
" return &str->s;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void simple6()
|
||||||
|
{
|
||||||
|
check( "static void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *str = strdup(\"hello\");\n"
|
||||||
|
" char *str2 = (char *)str;\n"
|
||||||
|
" free(str2);\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void simple7()
|
||||||
|
{
|
||||||
|
// A garbage collector may delete f automaticly
|
||||||
|
check( "class Fred;\n"
|
||||||
|
"void foo()\n"
|
||||||
|
"{\n"
|
||||||
|
" Fred *f = new Fred;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse1()
|
||||||
|
{
|
||||||
|
check( "void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" int *a = new int[10];\n"
|
||||||
|
" if (a)\n"
|
||||||
|
" {\n"
|
||||||
|
" delete [] a;\n"
|
||||||
|
" }\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse2()
|
||||||
|
{
|
||||||
|
check( "void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *str = strdup(\"hello\");\n"
|
||||||
|
" if (somecondition)\n"
|
||||||
|
" {\n"
|
||||||
|
" return;\n"
|
||||||
|
" }\n"
|
||||||
|
" free(str);\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string("[test.cpp:6]: Memory leak: str\n"), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse3()
|
||||||
|
{
|
||||||
|
check( "void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *str = strdup(\"hello\");\n"
|
||||||
|
" if (a==b)\n"
|
||||||
|
" {\n"
|
||||||
|
" free(str);\n"
|
||||||
|
" return;\n"
|
||||||
|
" }\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string("[test.cpp:9]: Memory leak: str\n"), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse4()
|
||||||
|
{
|
||||||
|
check( "void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *str = new char[10];\n"
|
||||||
|
" if (a==b)\n"
|
||||||
|
" {\n"
|
||||||
|
" delete [] str;\n"
|
||||||
|
" return;\n"
|
||||||
|
" }\n"
|
||||||
|
" delete [] str;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse5()
|
||||||
|
{
|
||||||
|
check( "void f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *str;\n"
|
||||||
|
" if (somecondition)\n"
|
||||||
|
" {\n"
|
||||||
|
" str = new char[100];\n"
|
||||||
|
" }\n"
|
||||||
|
" else\n"
|
||||||
|
" {\n"
|
||||||
|
" return;\n"
|
||||||
|
" }\n"
|
||||||
|
" delete [] str;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse6()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *s = new char[100];\n"
|
||||||
|
" if ( a == b )\n"
|
||||||
|
" {\n"
|
||||||
|
" return s;\n"
|
||||||
|
" }\n"
|
||||||
|
" return NULL;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string("[test.cpp:8]: Memory leak: s\n"), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse7()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *s;\n"
|
||||||
|
" if ( abc )\n"
|
||||||
|
" {\n"
|
||||||
|
" s = new char[10];\n"
|
||||||
|
" }\n"
|
||||||
|
" return s;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void ifelse8()
|
||||||
|
{
|
||||||
|
check( "static char *f()\n"
|
||||||
|
"{\n"
|
||||||
|
" char *s = new char[10];\n"
|
||||||
|
" if ( s )\n"
|
||||||
|
" {\n"
|
||||||
|
" return s;\n"
|
||||||
|
" }\n"
|
||||||
|
" return 0;\n"
|
||||||
|
"}\n" );
|
||||||
|
ASSERT_EQUALS( std::string(""), errout.str() );
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
REGISTER_FIXTURE( TestMemleak )
|
REGISTER_FIXTURE( TestMemleak )
|
||||||
|
|
|
||||||
173
tests.cpp
173
tests.cpp
|
|
@ -480,179 +480,6 @@ static void memleak_in_function()
|
||||||
// * function calls
|
// * function calls
|
||||||
|
|
||||||
|
|
||||||
const char *code;
|
|
||||||
|
|
||||||
|
|
||||||
////////////////////////////////////////////////
|
|
||||||
// Simple testcases
|
|
||||||
////////////////////////////////////////////////
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" int *a = new int[10];\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:4]: Memory leak: a\n" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "Fred *NewFred()\n"
|
|
||||||
"{\n"
|
|
||||||
" Fred *f = new Fred;\n"
|
|
||||||
" return f;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *s = new char[100];\n"
|
|
||||||
" return (char *)s;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *s = new char[100];\n"
|
|
||||||
" return 0;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:4]: Memory leak: s\n" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" struct *str = new strlist;\n"
|
|
||||||
" return &str->s;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *str = strdup(\"hello\");\n"
|
|
||||||
" char *str2 = (char *)str;\n"
|
|
||||||
" free(str2);\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
// Fred may be deleted automaticly by a garbage collector..
|
|
||||||
code = "class Fred;\n"
|
|
||||||
"void foo()\n"
|
|
||||||
"{\n"
|
|
||||||
" Fred *f = new Fred;\n"
|
|
||||||
"}\n";
|
|
||||||
ShowAll = false;
|
|
||||||
check( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
ShowAll = true;
|
|
||||||
|
|
||||||
|
|
||||||
////////////////////////////////////////////////
|
|
||||||
// if else
|
|
||||||
////////////////////////////////////////////////
|
|
||||||
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" int *a = new int[10];\n"
|
|
||||||
" if (a)\n"
|
|
||||||
" {\n"
|
|
||||||
" delete [] a;\n"
|
|
||||||
" }\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *str = strdup(\"hello\");\n"
|
|
||||||
" if (somecondition)\n"
|
|
||||||
" {\n"
|
|
||||||
" return;\n"
|
|
||||||
" }\n"
|
|
||||||
" free(str);\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:6]: Memory leak: str\n" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *str = strdup(\"hello\");\n"
|
|
||||||
" if (a==b)\n"
|
|
||||||
" {\n"
|
|
||||||
" free(str);\n"
|
|
||||||
" return;\n"
|
|
||||||
" }\n"
|
|
||||||
"}\n";
|
|
||||||
check( CheckMemoryLeak, __LINE__, code, "[test.cpp:9]: Memory leak: str\n" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *str = new char[10];\n"
|
|
||||||
" if (a==b)\n"
|
|
||||||
" {\n"
|
|
||||||
" delete [] str;\n"
|
|
||||||
" return;\n"
|
|
||||||
" }\n"
|
|
||||||
" delete [] str;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "void f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *str;\n"
|
|
||||||
" if (somecondition)\n"
|
|
||||||
" {\n"
|
|
||||||
" str = new char[100];\n"
|
|
||||||
" }\n"
|
|
||||||
" else\n"
|
|
||||||
" {\n"
|
|
||||||
" return;\n"
|
|
||||||
" }\n"
|
|
||||||
" delete [] str;\n"
|
|
||||||
"}\n";
|
|
||||||
ShowAll = false;
|
|
||||||
check( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
ShowAll = true;
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *s = new char[100];\n"
|
|
||||||
" if ( a == b )\n"
|
|
||||||
" {\n"
|
|
||||||
" return s;\n"
|
|
||||||
" }\n"
|
|
||||||
" return NULL;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:8]: Memory leak: s\n" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *s;\n"
|
|
||||||
" if ( abc )\n"
|
|
||||||
" {\n"
|
|
||||||
" s = new char[10];\n"
|
|
||||||
" }\n"
|
|
||||||
" return s;\n"
|
|
||||||
"}\n";
|
|
||||||
check_( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
|
|
||||||
|
|
||||||
code = "static char *f()\n"
|
|
||||||
"{\n"
|
|
||||||
" char *s = new char[10];\n"
|
|
||||||
" if ( s )\n"
|
|
||||||
" {\n"
|
|
||||||
" return s;\n"
|
|
||||||
" }\n"
|
|
||||||
" return 0;\n"
|
|
||||||
"}\n";
|
|
||||||
ShowAll = false;
|
|
||||||
check( CheckMemoryLeak, __LINE__, code, "" );
|
|
||||||
ShowAll = true;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
////////////////////////////////////////////////
|
////////////////////////////////////////////////
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue