tests: Removed this deprecated file

This commit is contained in:
Daniel Marjamäki 2008-11-05 23:50:40 +00:00
parent 9c565d5945
commit 877aea4bf7
1 changed files with 0 additions and 577 deletions

577
tests.cpp
View File

@ -1,577 +0,0 @@
// Unit-testing cppcheck
//---------------------------------------------------------------------------
#include "tokenize.h" // <- Tokenizer
#include "CommonCheck.h"
#include "CheckBufferOverrun.h"
#include "CheckClass.h"
#include "CheckMemoryLeak.h"
#include "CheckOther.h"
#include <iostream>
#include <sstream>
//---------------------------------------------------------------------------
bool ShowAll = true;
bool CheckCodingStyle = true;
bool Debug = false;
//---------------------------------------------------------------------------
static unsigned int FailCount, SuccessCount;
//---------------------------------------------------------------------------
static void constructors();
static void operator_eq();
static void memleak_in_function();
static void memleak_in_class();
static void variable_scope();
static void fpar_byvalue();
static void unused_struct_member();
//---------------------------------------------------------------------------
int main()
{
// Provide a dummy filename for the error messages
Files.push_back( std::string("test.cpp") );
// Don't filter out duplicate error messages..
OnlyReportUniqueErrors = false;
// Test the constructor-checks
constructors();
// Test the class operator= checking
operator_eq();
// Test that memory leaks in a function are detected
memleak_in_function();
// Test that memory leaks in a class are detected
memleak_in_class();
// variable scope..
variable_scope();
fpar_byvalue();
// unused struct member..
unused_struct_member();
// unused variable
std::cout << "Success Rate: "
<< SuccessCount
<< " / "
<< (SuccessCount + FailCount)
<< std::endl;
return 0;
}
//---------------------------------------------------------------------------
static void check(void (chk)(),
const unsigned int line,
const char code[],
const char msg[])
{
// Tokenize..
tokens = tokens_back = NULL;
std::istringstream istr(code);
TokenizeCode( istr );
if ( chk != CheckUnsignedDivision )
SimplifyTokenList();
FillFunctionList(0);
// Check for buffer overruns..
errout.str("");
chk();
// Check the error messages..
std::string err( errout.str() );
if ( err == msg )
{
SuccessCount++;
}
else
{
FailCount++;
std::cerr << "Failed at line " << line << std::endl
<< "Unexpected Result:" << std::endl
<< err << std::endl;
}
// Cleanup..
DeallocateTokens();
}
//---------------------------------------------------------------------------
static void constructors()
{
// Test1: No constructor
// Test2: embedded constructor, uninitialized variable
// Test3: Uninitialized variable
// Test4: multiple constructors, uninitialized variable
const char *code;
code = "class Fred\n"
"{\n"
"public:\n"
" int i;\n"
"};\n";
check( CheckConstructors, __LINE__, code, "[test.cpp:1] The class 'Fred' has no constructor\n" );
code = "class Fred\n"
"{\n"
"public:\n"
" Fred() { }\n"
" int i;\n"
"};\n";
check( CheckConstructors, __LINE__, code, "[test.cpp:4] Uninitialized member variable 'Fred::i'\n" );
code = "class Fred\n"
"{\n"
"public:\n"
" Fred();\n"
" int i;\n"
"};\n"
"Fred::Fred()\n"
"{ }\n";
check( CheckConstructors, __LINE__, code, "[test.cpp:7] Uninitialized member variable 'Fred::i'\n" );
code = "class Fred\n"
"{\n"
"public:\n"
" Fred();\n"
" Fred(int _i);\n"
" int i;\n"
"};\n"
"Fred::Fred()\n"
"{ }\n"
"Fred::Fred(int _i)\n"
"{\n"
" i = _i;\n"
"}\n";
check( CheckConstructors, __LINE__, code, "[test.cpp:8] Uninitialized member variable 'Fred::i'\n" );
}
//---------------------------------------------------------------------------
static void operator_eq()
{
const char *code;
code = "class Fred\n"
"{\n"
"public:\n"
" void operator=(const int &value);\n"
"};\n";
check( CheckOperatorEq1, __LINE__, code, "[test.cpp:4]: 'operator=' should return something\n" );
}
//---------------------------------------------------------------------------
static void memleak_in_function()
{
////////////////////////////////////////////////
// Garbage collection
////////////////////////////////////////////////
code = "static char *f()\n"
"{\n"
" Fred *fred = new Fred;\n"
" // fred is deleted automaticly\n"
"}\n";
check_( CheckMemoryLeak, __LINE__, code, "" );
code = "struct abc\n"
"{\n"
" int a;\n"
" int b;\n"
" int c;\n"
"}\n"
"\n"
"static void f()\n"
"{\n"
" struct abc *abc1 = new abc;\n"
" p = &abc1->a;\n" // p may be part of a garbage collector
"}\n";
check_( CheckMemoryLeak, __LINE__, code, "" );
////////////////////////////////////////////////
// arrays
////////////////////////////////////////////////
/* TODO
code = "static void f()\n"
"{\n"
" char *str[10];\n"
" str[0] = strdup(\"hello\");\n"
"}\n";
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:3]: Memory leak: str[0]\n" );
*/
////////////////////////////////////////////////
// struct members
////////////////////////////////////////////////
code = "static char *f()\n"
"{\n"
" Fred *fred = new Fred;\n"
" free( fred->Name );\n"
"}\n";
check( CheckMemoryLeak, __LINE__, code, "[test.cpp:5]: Memory leak: fred\n" );
/* TODO
code = "struct Fred\n"
"{\n"
" char *str;\n"
"}\n"
"\n"
"void f()\n"
"{\n"
" Fred f;\n"
" f.str = strdup(\"aa\");\n"
"}\n";
check_( CheckMemoryLeak, __LINE__, code, "[test.cpp:9]: Memory leak: f.str\n" );
*/
code = "static struct fib6_table *fib6_alloc_table(struct net *net, u32 id)\n"
"{\n"
" struct fib6_table *table;\n"
"\n"
" table = kzalloc(sizeof(*table), GFP_ATOMIC);\n"
" if (table != NULL) {\n"
" table->tb6_id = id;\n"
" table->tb6_root.leaf = net->ipv6.ip6_null_entry;\n"
" table->tb6_root.fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO;\n"
" }\n"
"\n"
" return table;\n"
"}\n";
ShowAll = false;
check( CheckMemoryLeak, __LINE__, code, "" );
ShowAll = true;
}
//---------------------------------------------------------------------------
static void memleak_in_class()
{
const char *code;
code = "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"
"}\n";
check( CheckMemoryLeak, __LINE__, code, "[test.cpp:1]: Memory leak: Fred::str1\n" );
code = "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"
"}\n";
check( CheckMemoryLeak, __LINE__, code, "[test.cpp:17]: Mismatching allocation and deallocation: Fred::str1\n" );
/* TODO
code = "class Fred\n"
"{\n"
"private:\n"
" char *str;\n"
"public:\n"
" Fred();\n"
" ~Fred();\n"
" void SetStr(const char s[]);"
"};\n"
"\n"
"Fred::Fred()\n"
"{\n"
" str = NULL;\n"
"}\n"
"\n"
"Fred::~Fred()\n"
"{\n"
" free(str1);\n"
"}\n"
"\n"
"void Fred::SetStr(const char s[])\n"
"{\n"
" str = strdup(s);\n"
"}\n";
check( CheckMemoryLeak, __LINE__, code, "Memory leak for 'Fred::str'\n" );
*/
}
//---------------------------------------------------------------------------
static void variable_scope()
{
const char *code;
/* TODO
// Unused private member variable...
code = "class Fred\n"
"{\n"
"private:\n"
" int i;\n"
"public:\n"
" Fred();\n"
"};\n"
"Fred::Fred()\n"
"{\n"
" i = 0;\n"
"}\n";
*/
// Scope of variable..
code = "void f()\n"
"{\n"
" int i;\n"
" if (abc)\n"
" {\n"
" i = 1;\n"
" }\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "[test.cpp:3] The scope of the variable 'i' can be limited\n" );
code = "static void DeleteNextToken(TOKEN *tok)\n"
"{\n"
" TOKEN *next = tok->next;\n"
" tok->next = next->next;\n"
" free(next->str);\n"
" delete next;\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
" bool special = false;\n"
" do\n"
" {\n"
" // Special sequence\n"
" if (special)\n"
" special = false;\n"
" else\n"
" special = (c == \'\\\');\n"
" }\n"
" while (special || c != \'\"\');\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
" int i = 0;\n"
" {\n"
" i+5;\n"
" }\n"
" {\n"
" i+5;\n"
" }\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
"#define F1(x, y, z) (z ^ (x & (y ^ z)))\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "struct a\n"
"{\n"
" int x;\n"
" int y;\n"
"};\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
" struct\n"
" {\n"
" int x;\n"
" int y;\n"
" } fred;\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
" int i;\n"
" while (abc)\n"
" {\n"
" if (cond1)\n"
" {\n"
" i = 2;\n"
" }\n"
" if (cond2)\n"
" {\n"
" f(i);\n"
" }\n"
" }\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
code = "static void f()\n"
"{\n"
" TPoint p1;\n"
" for (i=0;i<10;i++)\n"
" {\n"
" p1=point(i,i);\n"
" }\n"
"}\n";
check( CheckVariableScope, __LINE__, code, "" );
}
//---------------------------------------------------------------------------
static void fpar_byvalue()
{
check( CheckConstantFunctionParameter,
__LINE__,
"void f(const std::string str);",
"[test.cpp:1] str is passed by value, it could be passed by reference/pointer instead\n" );
/* TODO
check( CheckConstantFunctionParameter,
__LINE__,
"void f(const int a, const std::vector<int> v, const int b);",
"[test.cpp:1] v is passed by value, it could be passed by reference/pointer instead\n" );
*/
check( CheckConstantFunctionParameter,
__LINE__,
"class Fred;\n"
"void f(const Fred f);",
"[test.cpp:2] f is passed by value, it could be passed by reference/pointer instead\n" );
}
//---------------------------------------------------------------------------
static void unused_struct_member()
{
check( CheckStructMemberUsage,
__LINE__,
"struct abc {int i;};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {unsigned int i;};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {int *i;};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {unsigned int *i;};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {int i[10];};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {unsigned int i[10];};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {int *i[10];};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
check( CheckStructMemberUsage,
__LINE__,
"struct abc {unsigned int *i[10];};",
"[test.cpp:1]: struct member 'abc::i' is never read\n" );
}
//---------------------------------------------------------------------------