9668 lines
159 KiB
C++
9668 lines
159 KiB
C++
// auto generated tests from cfg/posix.cfg
|
|
//
|
|
// Generated by command:
|
|
// ./generate_cfg_tests cfg/posix.cfg > generated-cfg-tests-posix.cpp
|
|
//
|
|
// Recommended cppcheck command line:
|
|
// $ cppcheck --enable=warning,information --inline-suppr --platform=unix64 generated-cfg-tests-posix.cpp
|
|
// => 'unmatched suppression' warnings are false negatives.
|
|
//
|
|
|
|
void test__a64l__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = a64l(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__a64l__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
a64l(arg1);
|
|
}
|
|
|
|
void test__a64l__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = a64l(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__a64l__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = a64l(NULL);
|
|
}
|
|
|
|
void test__a64l__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = a64l(x);
|
|
}
|
|
|
|
void test__l64a__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = l64a(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__l64a__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
l64a(arg1);
|
|
}
|
|
|
|
void test__l64a__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = l64a(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__l64a__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = l64a(x);
|
|
}
|
|
|
|
void test__accept__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
accept(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__accept__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
accept(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__accept__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
accept(x, arg2, arg3);
|
|
}
|
|
|
|
void test__accept__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
accept(arg1, x, arg3);
|
|
}
|
|
|
|
void test__accept__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
accept(arg1, arg2, x);
|
|
}
|
|
|
|
void test__access__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = access(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__access__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
access(arg1, arg2);
|
|
}
|
|
|
|
void test__access__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = access(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__access__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = access(NULL, arg2);
|
|
}
|
|
|
|
void test__access__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = access(x, arg2);
|
|
}
|
|
|
|
void test__access__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = access(arg1, x);
|
|
}
|
|
|
|
void test__adjtime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
adjtime(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__adjtime__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
adjtime(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__adjtime__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
adjtime(x, arg2);
|
|
}
|
|
|
|
void test__gettimeofday__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
gettimeofday(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gettimeofday__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
gettimeofday(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__settimeofday__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
settimeofday(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__settimeofday__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
settimeofday(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__settimeofday__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
settimeofday(x, arg2);
|
|
}
|
|
|
|
void test__settimeofday__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
settimeofday(arg1, x);
|
|
}
|
|
|
|
void test__FD_CLR__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
FD_CLR(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__FD_CLR__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
FD_CLR(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__FD_CLR__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
FD_CLR(x, arg2);
|
|
}
|
|
|
|
void test__FD_CLR__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
FD_CLR(arg1, NULL);
|
|
}
|
|
|
|
void test__FD_ISSET__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
FD_ISSET(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__FD_ISSET__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
FD_ISSET(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__FD_ISSET__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
FD_ISSET(x, arg2);
|
|
}
|
|
|
|
void test__FD_ISSET__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
FD_ISSET(arg1, NULL);
|
|
}
|
|
|
|
void test__FD_SET__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
FD_SET(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__FD_SET__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
FD_SET(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__FD_SET__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
FD_SET(x, arg2);
|
|
}
|
|
|
|
void test__FD_SET__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
FD_SET(arg1, NULL);
|
|
}
|
|
|
|
void test__FD_ZERO__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
FD_ZERO(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__FD_ZERO__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
FD_ZERO(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__FD_ZERO__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
FD_ZERO(NULL);
|
|
}
|
|
|
|
void test__fdatasync__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fdatasync(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fdatasync__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fdatasync(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fdatasync__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fdatasync(x);
|
|
}
|
|
|
|
void test__fnmatch__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fnmatch(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fnmatch__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fnmatch(arg1, arg2, arg3);
|
|
}
|
|
|
|
void test__fnmatch__pure(int arg1,int arg2,int arg3)
|
|
{
|
|
// cppcheck-suppress incorrectLogicOperator
|
|
if ((fnmatch(arg1, arg2, arg3) > 10) || (fnmatch(arg1, arg2, arg3) < 100)) {}
|
|
}
|
|
|
|
void test__fnmatch__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = fnmatch(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fnmatch__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fnmatch(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__fnmatch__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fnmatch(x, arg2, arg3);
|
|
}
|
|
|
|
void test__fnmatch__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fnmatch(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__fnmatch__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fnmatch(arg1, x, arg3);
|
|
}
|
|
|
|
void test__fnmatch__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = fnmatch(arg1, arg2, x);
|
|
}
|
|
|
|
void test__fsync__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fsync(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fsync__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fsync(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fsync__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fsync(x);
|
|
}
|
|
|
|
void test__truncate__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
truncate(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__truncate__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
truncate(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__truncate__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
truncate(NULL, arg2);
|
|
}
|
|
|
|
void test__truncate__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
truncate(x, arg2);
|
|
}
|
|
|
|
void test__truncate__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
truncate(arg1, x);
|
|
}
|
|
|
|
void test__ftruncate__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ftruncate(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ftruncate__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ftruncate(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ftruncate__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ftruncate(x, arg2);
|
|
}
|
|
|
|
void test__ftruncate__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ftruncate(arg1, x);
|
|
}
|
|
|
|
void test__flock__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
flock(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__flock__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
flock(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__flock__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
flock(x, arg2);
|
|
}
|
|
|
|
void test__flock__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
flock(arg1, x);
|
|
}
|
|
|
|
void test__symlink__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
symlink(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__symlink__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
symlink(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__symlink__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
symlink(NULL, arg2);
|
|
}
|
|
|
|
void test__symlink__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
symlink(x, arg2);
|
|
}
|
|
|
|
void test__symlink__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
symlink(arg1, NULL);
|
|
}
|
|
|
|
void test__symlink__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
symlink(arg1, x);
|
|
}
|
|
|
|
void test__open__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
open(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__open__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
open(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__open__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
open(x, arg2, arg3);
|
|
}
|
|
|
|
void test__open__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
open(arg1, x, arg3);
|
|
}
|
|
|
|
void test__open__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
open(arg1, arg2, x);
|
|
}
|
|
|
|
void test__creat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = creat(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__creat__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
creat(arg1, arg2);
|
|
}
|
|
|
|
void test__creat__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = creat(NULL, arg2);
|
|
}
|
|
|
|
void test__creat__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = creat(x, arg2);
|
|
}
|
|
|
|
void test__creat__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = creat(arg1, x);
|
|
}
|
|
|
|
void test__sleep__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sleep(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sleep__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sleep(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sleep__arg1__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
sleep(!x);
|
|
}
|
|
|
|
void test__sleep__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sleep(x);
|
|
}
|
|
|
|
void test__usleep__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
usleep(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__usleep__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
usleep(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__usleep__arg1__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
usleep(!x);
|
|
}
|
|
|
|
void test___exit__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
_exit(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test___exit__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
_exit(x);
|
|
}
|
|
|
|
void test__faccessat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
faccessat(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__faccessat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
faccessat(p, arg2, arg3, arg4);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__faccessat__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
faccessat(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__faccessat__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
faccessat(arg1, NULL, arg3, arg4);
|
|
}
|
|
|
|
void test__faccessat__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
faccessat(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__faccessat__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
faccessat(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__faccessat__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
faccessat(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__acct__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
acct(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__acct__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
acct(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__acct__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
acct(x);
|
|
}
|
|
|
|
void test__alarm__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
alarm(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__alarm__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
alarm(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__alarm__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
alarm(x);
|
|
}
|
|
|
|
void test__getrpcent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getrpcent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getrpcent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getrpcent();
|
|
}
|
|
|
|
void test__getrpcent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getrpcent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrpcbyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getrpcbyname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getrpcbyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getrpcbyname(arg1);
|
|
}
|
|
|
|
void test__getrpcbyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getrpcbyname(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrpcbyname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getrpcbyname(NULL);
|
|
}
|
|
|
|
void test__getrpcbyname__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getrpcbyname(x);
|
|
}
|
|
|
|
void test__getrpcbynumber__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getrpcbynumber(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getrpcbynumber__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getrpcbynumber(arg1);
|
|
}
|
|
|
|
void test__getrpcbynumber__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getrpcbynumber(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrpcbynumber__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getrpcbynumber(x);
|
|
}
|
|
|
|
void test__getprotoent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getprotoent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getprotoent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getprotoent();
|
|
}
|
|
|
|
void test__getprotoent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getprotoent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getprotobyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getprotobyname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getprotobyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getprotobyname(arg1);
|
|
}
|
|
|
|
void test__getprotobyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getprotobyname(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getprotobyname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getprotobyname(NULL);
|
|
}
|
|
|
|
void test__getprotobyname__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getprotobyname(x);
|
|
}
|
|
|
|
void test__getprotobynumber__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getprotobynumber(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getprotobynumber__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getprotobynumber(arg1);
|
|
}
|
|
|
|
void test__getprotobynumber__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getprotobynumber(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getprotobynumber__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getprotobynumber(x);
|
|
}
|
|
|
|
void test__getservent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getservent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getservent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getservent();
|
|
}
|
|
|
|
void test__getservent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getservent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getservbyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getservbyname(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getservbyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getservbyname(arg1, arg2);
|
|
}
|
|
|
|
void test__getservbyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getservbyname(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getservbyname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getservbyname(NULL, arg2);
|
|
}
|
|
|
|
void test__getservbyname__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getservbyname(x, arg2);
|
|
}
|
|
|
|
void test__getservbyname__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getservbyname(arg1, x);
|
|
}
|
|
|
|
void test__getservbyport__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getservbyport(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getservbyport__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getservbyport(arg1, arg2);
|
|
}
|
|
|
|
void test__getservbyport__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getservbyport(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getservbyport__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getservbyport(x, arg2);
|
|
}
|
|
|
|
void test__getservbyport__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getservbyport(arg1, x);
|
|
}
|
|
|
|
void test__getnetent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getnetent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getnetent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getnetent();
|
|
}
|
|
|
|
void test__getnetent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getnetent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getnetbyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getnetbyname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getnetbyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getnetbyname(arg1);
|
|
}
|
|
|
|
void test__getnetbyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getnetbyname(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getnetbyname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getnetbyname(NULL);
|
|
}
|
|
|
|
void test__getnetbyname__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getnetbyname(x);
|
|
}
|
|
|
|
void test__getnetbyaddr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getnetbyaddr(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getnetbyaddr__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getnetbyaddr(arg1, arg2);
|
|
}
|
|
|
|
void test__getnetbyaddr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getnetbyaddr(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getnetbyaddr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getnetbyaddr(x, arg2);
|
|
}
|
|
|
|
void test__getnetbyaddr__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getnetbyaddr(arg1, x);
|
|
}
|
|
|
|
void test__gethostent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = gethostent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gethostent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
gethostent();
|
|
}
|
|
|
|
void test__gethostent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = gethostent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gethostbyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = gethostbyname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gethostbyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
gethostbyname(arg1);
|
|
}
|
|
|
|
void test__gethostbyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = gethostbyname(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gethostbyname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = gethostbyname(NULL);
|
|
}
|
|
|
|
void test__gethostbyname__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyname(x);
|
|
}
|
|
|
|
void test__gethostbyname2__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = gethostbyname2(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gethostbyname2__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
gethostbyname2(arg1, arg2);
|
|
}
|
|
|
|
void test__gethostbyname2__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = gethostbyname2(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gethostbyname2__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = gethostbyname2(NULL, arg2);
|
|
}
|
|
|
|
void test__gethostbyname2__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyname2(x, arg2);
|
|
}
|
|
|
|
void test__gethostbyname2__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyname2(arg1, x);
|
|
}
|
|
|
|
void test__gethostbyaddr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = gethostbyaddr(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gethostbyaddr__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
gethostbyaddr(arg1, arg2, arg3);
|
|
}
|
|
|
|
void test__gethostbyaddr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = gethostbyaddr(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gethostbyaddr__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = gethostbyaddr(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__gethostbyaddr__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyaddr(x, arg2, arg3);
|
|
}
|
|
|
|
void test__gethostbyaddr__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyaddr(arg1, x, arg3);
|
|
}
|
|
|
|
void test__gethostbyaddr__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = gethostbyaddr(arg1, arg2, x);
|
|
}
|
|
|
|
void test__brk__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
brk(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__brk__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
brk(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__brk__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
brk(NULL);
|
|
}
|
|
|
|
void test__sbrk__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sbrk(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sbrk__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sbrk(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sbrk__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sbrk(x);
|
|
}
|
|
|
|
void test__closedir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
closedir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__closedir__arg1__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
closedir(!x);
|
|
}
|
|
|
|
void test__closedir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
closedir(NULL);
|
|
}
|
|
|
|
void test__closedir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
closedir(x);
|
|
}
|
|
|
|
void test__strfry__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strfry(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strfry__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strfry(NULL);
|
|
}
|
|
|
|
void test__strsep__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strsep(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strsep__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
strsep(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__strsep__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strsep(NULL, arg2);
|
|
}
|
|
|
|
void test__strsep__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strsep(x, arg2);
|
|
}
|
|
|
|
void test__strsep__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strsep(arg1, NULL);
|
|
}
|
|
|
|
void test__strsep__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strsep(arg1, x);
|
|
}
|
|
|
|
void test__strdup__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strdup(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strdup__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strdup(NULL);
|
|
}
|
|
|
|
void test__strdup__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strdup(x);
|
|
}
|
|
|
|
void test__strndup__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strndup(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strndup__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strndup(NULL, arg2);
|
|
}
|
|
|
|
void test__strndup__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strndup(x, arg2);
|
|
}
|
|
|
|
void test__strndup__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
strndup(arg1, x);
|
|
}
|
|
|
|
void test__wcsdup__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
wcsdup(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__wcsdup__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
wcsdup(NULL);
|
|
}
|
|
|
|
void test__wcsdup__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
wcsdup(x);
|
|
}
|
|
|
|
void test__mkstemp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mkstemp(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mkstemp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
mkstemp(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mkstemp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
mkstemp(NULL);
|
|
}
|
|
|
|
void test__mkstemp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
mkstemp(x);
|
|
}
|
|
|
|
void test__mkdtemp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mkdtemp(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mkdtemp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
mkdtemp(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mkdtemp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
mkdtemp(NULL);
|
|
}
|
|
|
|
void test__mkdtemp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
mkdtemp(x);
|
|
}
|
|
|
|
void test__mktemp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = mktemp(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mktemp__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
mktemp(arg1);
|
|
}
|
|
|
|
void test__mktemp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = mktemp(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mktemp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = mktemp(NULL);
|
|
}
|
|
|
|
void test__mktemp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = mktemp(x);
|
|
}
|
|
|
|
void test__getcwd__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getcwd(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getcwd__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getcwd(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getcwd__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getcwd(x, arg2);
|
|
}
|
|
|
|
void test__getcwd__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getcwd(arg1, x);
|
|
}
|
|
|
|
void test__mkdir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mkdir(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mkdir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
mkdir(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mkdir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
mkdir(NULL, arg2);
|
|
}
|
|
|
|
void test__mkdir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
mkdir(x, arg2);
|
|
}
|
|
|
|
void test__mkdir__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mkdir(arg1, x);
|
|
}
|
|
|
|
void test__rmdir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
rmdir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rmdir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
rmdir(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__rmdir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
rmdir(NULL);
|
|
}
|
|
|
|
void test__rmdir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
rmdir(x);
|
|
}
|
|
|
|
void test__chdir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
chdir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__chdir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
chdir(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__chdir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
chdir(NULL);
|
|
}
|
|
|
|
void test__chdir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
chdir(x);
|
|
}
|
|
|
|
void test__chroot__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
chroot(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__chroot__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
chroot(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__chroot__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
chroot(NULL);
|
|
}
|
|
|
|
void test__chroot__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
chroot(x);
|
|
}
|
|
|
|
void test__link__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
link(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__link__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
link(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__link__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
link(NULL, arg2);
|
|
}
|
|
|
|
void test__link__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
link(x, arg2);
|
|
}
|
|
|
|
void test__link__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
link(arg1, NULL);
|
|
}
|
|
|
|
void test__link__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
link(arg1, x);
|
|
}
|
|
|
|
void test__unlink__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
unlink(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__unlink__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
unlink(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__unlink__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
unlink(NULL);
|
|
}
|
|
|
|
void test__unlink__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
unlink(x);
|
|
}
|
|
|
|
void test__rename__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
rename(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rename__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
rename(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__rename__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
rename(NULL);
|
|
}
|
|
|
|
void test__rename__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
rename(x);
|
|
}
|
|
|
|
void test__stat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
stat(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__stat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
stat(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__stat__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stat(NULL, arg2);
|
|
}
|
|
|
|
void test__stat__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
stat(x, arg2);
|
|
}
|
|
|
|
void test__stat__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stat(arg1, NULL);
|
|
}
|
|
|
|
void test__lstat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
lstat(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__lstat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
lstat(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__lstat__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
lstat(NULL, arg2);
|
|
}
|
|
|
|
void test__lstat__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
lstat(x, arg2);
|
|
}
|
|
|
|
void test__lstat__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
lstat(arg1, NULL);
|
|
}
|
|
|
|
void test__fstat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fstat(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fstat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fstat(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fstat__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fstat(x, arg2);
|
|
}
|
|
|
|
void test__fstat__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
fstat(arg1, NULL);
|
|
}
|
|
|
|
void test__chmod__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
chmod(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__chmod__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
chmod(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__chmod__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
chmod(NULL, arg2);
|
|
}
|
|
|
|
void test__chmod__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
chmod(x, arg2);
|
|
}
|
|
|
|
void test__chmod__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
chmod(arg1, x);
|
|
}
|
|
|
|
void test__fchmod__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fchmod(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fchmod__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fchmod(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fchmod__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fchmod(x, arg2);
|
|
}
|
|
|
|
void test__fchmod__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fchmod(arg1, x);
|
|
}
|
|
|
|
void test__chown__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
chown(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__chown__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
chown(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__chown__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
chown(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__chown__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
chown(x, arg2, arg3);
|
|
}
|
|
|
|
void test__chown__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
chown(arg1, x, arg3);
|
|
}
|
|
|
|
void test__chown__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
chown(arg1, arg2, x);
|
|
}
|
|
|
|
void test__lchown__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
lchown(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__lchown__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
lchown(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__lchown__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
lchown(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__lchown__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
lchown(x, arg2, arg3);
|
|
}
|
|
|
|
void test__lchown__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
lchown(arg1, x, arg3);
|
|
}
|
|
|
|
void test__lchown__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
lchown(arg1, arg2, x);
|
|
}
|
|
|
|
void test__fchown__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fchown(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fchown__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fchown(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fchown__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fchown(x, arg2, arg3);
|
|
}
|
|
|
|
void test__fchown__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fchown(arg1, x, arg3);
|
|
}
|
|
|
|
void test__fchown__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fchown(arg1, arg2, x);
|
|
}
|
|
|
|
void test__times__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
times(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__times__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
times(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__times__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
times(x);
|
|
}
|
|
|
|
void test__utime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
utime(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__utime__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
utime(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__utime__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
utime(NULL, arg2);
|
|
}
|
|
|
|
void test__utime__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
utime(x, arg2);
|
|
}
|
|
|
|
void test__utime__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
utime(arg1, x);
|
|
}
|
|
|
|
void test__utimes__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
utimes(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__utimes__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
utimes(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__utimes__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
utimes(NULL, arg2);
|
|
}
|
|
|
|
void test__utimes__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
utimes(x, arg2);
|
|
}
|
|
|
|
void test__utimes__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
utimes(arg1, x);
|
|
}
|
|
|
|
void test__opendir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = opendir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__opendir__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
opendir(arg1);
|
|
}
|
|
|
|
void test__opendir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = opendir(NULL);
|
|
}
|
|
|
|
void test__opendir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = opendir(x);
|
|
}
|
|
|
|
void test__fdopendir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fdopendir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fdopendir__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fdopendir(arg1);
|
|
}
|
|
|
|
void test__fdopendir__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = fdopendir(x);
|
|
}
|
|
|
|
void test__isatty__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = isatty(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__isatty__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
isatty(arg1);
|
|
}
|
|
|
|
void test__isatty__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = isatty(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__isatty__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = isatty(x);
|
|
}
|
|
|
|
void test__popen__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = popen(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__popen__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
popen(arg1, arg2);
|
|
}
|
|
|
|
void test__popen__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = popen(NULL, arg2);
|
|
}
|
|
|
|
void test__popen__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = popen(x, arg2);
|
|
}
|
|
|
|
void test__popen__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = popen(arg1, NULL);
|
|
}
|
|
|
|
void test__popen__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = popen(arg1, x);
|
|
}
|
|
|
|
void test__pclose__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pclose(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pclose__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pclose(NULL);
|
|
}
|
|
|
|
void test__pclose__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
pclose(x);
|
|
}
|
|
|
|
void test__socket__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
socket(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__socket__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
socket(x, arg2, arg3);
|
|
}
|
|
|
|
void test__socket__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
socket(arg1, x, arg3);
|
|
}
|
|
|
|
void test__socket__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
socket(arg1, arg2, x);
|
|
}
|
|
|
|
void test__nice__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
nice(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__nice__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
nice(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__nice__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
nice(x);
|
|
}
|
|
|
|
void test__pause__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pause();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pause__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
pause();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__close__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
close(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__close__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
close(x);
|
|
}
|
|
|
|
void test__confstr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
confstr(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__confstr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
confstr(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__confstr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
confstr(x, arg2, arg3);
|
|
}
|
|
|
|
void test__confstr__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
confstr(arg1, x, arg3);
|
|
}
|
|
|
|
void test__confstr__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
confstr(arg1, arg2, x);
|
|
}
|
|
|
|
void test__fpathconf__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fpathconf(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fpathconf__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fpathconf(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fpathconf__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fpathconf(x, arg2);
|
|
}
|
|
|
|
void test__fpathconf__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fpathconf(arg1, x);
|
|
}
|
|
|
|
void test__pathconf__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pathconf(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pathconf__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
pathconf(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__pathconf__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pathconf(NULL, arg2);
|
|
}
|
|
|
|
void test__pathconf__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
pathconf(x, arg2);
|
|
}
|
|
|
|
void test__pathconf__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pathconf(arg1, x);
|
|
}
|
|
|
|
void test__sysconf__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sysconf(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sysconf__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sysconf(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sysconf__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sysconf(x);
|
|
}
|
|
|
|
void test__fdopen__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fdopen(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fdopen__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fdopen(arg1, arg2);
|
|
}
|
|
|
|
void test__fdopen__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = fdopen(x, arg2);
|
|
}
|
|
|
|
void test__fdopen__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fdopen(arg1, NULL);
|
|
}
|
|
|
|
void test__fdopen__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fdopen(arg1, x);
|
|
}
|
|
|
|
void test__random__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = random();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__random__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
random();
|
|
}
|
|
|
|
void test__srandom__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
srandom(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rewinddir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
rewinddir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rewinddir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
rewinddir(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__rewinddir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
rewinddir(NULL);
|
|
}
|
|
|
|
void test__rewinddir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
rewinddir(x);
|
|
}
|
|
|
|
void test__seekdir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
seekdir(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__seekdir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
seekdir(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__seekdir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
seekdir(NULL, arg2);
|
|
}
|
|
|
|
void test__seekdir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
seekdir(x, arg2);
|
|
}
|
|
|
|
void test__seekdir__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
seekdir(arg1, x);
|
|
}
|
|
|
|
void test__rand_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
rand_r(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rand_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
rand_r(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__rand_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
rand_r(NULL);
|
|
}
|
|
|
|
void test__strcasecmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strcasecmp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strcasecmp__pure(int arg1,int arg2)
|
|
{
|
|
// cppcheck-suppress incorrectLogicOperator
|
|
if ((strcasecmp(arg1, arg2) > 10) || (strcasecmp(arg1, arg2) < 100)) {}
|
|
}
|
|
|
|
void test__strcasecmp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
strcasecmp(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__strcasecmp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strcasecmp(NULL, arg2);
|
|
}
|
|
|
|
void test__strcasecmp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strcasecmp(x, arg2);
|
|
}
|
|
|
|
void test__strcasecmp__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strcasecmp(arg1, NULL);
|
|
}
|
|
|
|
void test__strcasecmp__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strcasecmp(arg1, x);
|
|
}
|
|
|
|
void test__strncasecmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strncasecmp(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strncasecmp__pure(int arg1,int arg2,int arg3)
|
|
{
|
|
// cppcheck-suppress incorrectLogicOperator
|
|
if ((strncasecmp(arg1, arg2, arg3) > 10) || (strncasecmp(arg1, arg2, arg3) < 100)) {}
|
|
}
|
|
|
|
void test__strncasecmp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
strncasecmp(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__strncasecmp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strncasecmp(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__strncasecmp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strncasecmp(x, arg2, arg3);
|
|
}
|
|
|
|
void test__strncasecmp__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strncasecmp(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__strncasecmp__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strncasecmp(arg1, x, arg3);
|
|
}
|
|
|
|
void test__strncasecmp__arg3__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
strncasecmp(arg1, arg2, !x);
|
|
}
|
|
|
|
void test__read__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
read(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__read__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
read(x, arg2, arg3);
|
|
}
|
|
|
|
void test__read__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
read(arg1, arg2, x);
|
|
}
|
|
|
|
void test__write__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
write(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__write__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
write(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__write__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
write(x, arg2, arg3);
|
|
}
|
|
|
|
void test__write__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
write(arg1, x, arg3);
|
|
}
|
|
|
|
void test__write__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
write(arg1, arg2, x);
|
|
}
|
|
|
|
void test__recv__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recv(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__recv__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recv(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__recv__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recv(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__recvfrom__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recvfrom(x, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__recvfrom__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recvfrom(arg1, arg2, x, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__recvfrom__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recvfrom(arg1, arg2, arg3, x, arg5, arg6);
|
|
}
|
|
|
|
void test__recvmsg__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recvmsg(x, arg2, arg3);
|
|
}
|
|
|
|
void test__recvmsg__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
recvmsg(arg1, arg2, x);
|
|
}
|
|
|
|
void test__send__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
send(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__send__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
send(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__send__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
send(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__sendto__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendto(x, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__sendto__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendto(arg1, arg2, x, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__sendto__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendto(arg1, arg2, arg3, x, arg5, arg6);
|
|
}
|
|
|
|
void test__sendmsg__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendmsg(x, arg2, arg3);
|
|
}
|
|
|
|
void test__sendmsg__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendmsg(arg1, x, arg3);
|
|
}
|
|
|
|
void test__sendmsg__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sendmsg(arg1, arg2, x);
|
|
}
|
|
|
|
void test__mmap__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = mmap(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mmap__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
mmap(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = mmap(p, arg2, arg3, arg4, arg5, arg6);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mmap__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(x, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(arg1, x, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(arg1, arg2, x, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(arg1, arg2, arg3, x, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap__arg5__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(arg1, arg2, arg3, arg4, x, arg6);
|
|
}
|
|
|
|
void test__mmap__arg6__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap(arg1, arg2, arg3, arg4, arg5, x);
|
|
}
|
|
|
|
void test__mmap64__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mmap64__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
mmap64(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap64__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__mmap64__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(x, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap64__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(arg1, x, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap64__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(arg1, arg2, x, arg4, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap64__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(arg1, arg2, arg3, x, arg5, arg6);
|
|
}
|
|
|
|
void test__mmap64__arg5__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(arg1, arg2, arg3, arg4, x, arg6);
|
|
}
|
|
|
|
void test__mmap64__arg6__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = mmap64(arg1, arg2, arg3, arg4, arg5, x);
|
|
}
|
|
|
|
void test__munmap__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
munmap(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__munmap__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
munmap(NULL, arg2);
|
|
}
|
|
|
|
void test__munmap__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
munmap(x, arg2);
|
|
}
|
|
|
|
void test__munmap__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
munmap(arg1, x);
|
|
}
|
|
|
|
void test__openlog__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
openlog(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__openlog__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
openlog(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__openlog__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
openlog(x, arg2, arg3);
|
|
}
|
|
|
|
void test__openlog__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
openlog(arg1, x, arg3);
|
|
}
|
|
|
|
void test__openlog__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
openlog(arg1, arg2, x);
|
|
}
|
|
|
|
void test__fcntl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fcntl(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fcntl__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fcntl(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fcntl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fcntl(x, arg2);
|
|
}
|
|
|
|
void test__fcntl__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fcntl(arg1, x);
|
|
}
|
|
|
|
void test__ioctl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ioctl(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ioctl__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ioctl(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ioctl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ioctl(x, arg2);
|
|
}
|
|
|
|
void test__ioctl__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ioctl(arg1, x);
|
|
}
|
|
|
|
void test__syslog__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
syslog(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__syslog__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
syslog(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__syslog__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
syslog(x, arg2);
|
|
}
|
|
|
|
void test__vsyslog__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
vsyslog(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__vsyslog__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
vsyslog(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__vsyslog__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
vsyslog(x, arg2);
|
|
}
|
|
|
|
void test__getgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getgid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getgid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getgid();
|
|
}
|
|
|
|
void test__getegid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getegid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getegid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getegid();
|
|
}
|
|
|
|
void test__getuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getuid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getuid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getuid();
|
|
}
|
|
|
|
void test__getuid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getuid();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getsid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getsid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getsid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getsid(arg1);
|
|
}
|
|
|
|
void test__getsid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getsid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getsid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getsid(x);
|
|
}
|
|
|
|
void test__geteuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = geteuid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__geteuid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
geteuid();
|
|
}
|
|
|
|
void test__geteuid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = geteuid();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getppid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getppid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getppid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getppid();
|
|
}
|
|
|
|
void test__getppid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getppid();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getpid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpid();
|
|
}
|
|
|
|
void test__getpid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getpid();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getpgrp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpgrp();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpgrp__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpgrp();
|
|
}
|
|
|
|
void test__getpgrp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getpgrp();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getpgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpgid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpgid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpgid(arg1);
|
|
}
|
|
|
|
void test__getpgid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getpgid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getpgid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getpgid(x);
|
|
}
|
|
|
|
void test__setuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = setuid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setuid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
setuid(arg1);
|
|
}
|
|
|
|
void test__setuid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = setuid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setuid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = setuid(x);
|
|
}
|
|
|
|
void test__seteuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = seteuid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__seteuid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
seteuid(arg1);
|
|
}
|
|
|
|
void test__seteuid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = seteuid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__seteuid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = seteuid(x);
|
|
}
|
|
|
|
void test__setgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = setgid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setgid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
setgid(arg1);
|
|
}
|
|
|
|
void test__setgid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = setgid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setgid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = setgid(x);
|
|
}
|
|
|
|
void test__setegid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = setegid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setegid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
setegid(arg1);
|
|
}
|
|
|
|
void test__setegid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = setegid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setegid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = setegid(x);
|
|
}
|
|
|
|
void test__setpgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setpgid(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setpgid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setpgid(x, arg2);
|
|
}
|
|
|
|
void test__setpgid__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setpgid(arg1, x);
|
|
}
|
|
|
|
void test__pipe__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pipe();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setpgrp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setpgrp();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setregid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setregid(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setregid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setregid(x, arg2);
|
|
}
|
|
|
|
void test__setregid__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setregid(arg1, x);
|
|
}
|
|
|
|
void test__setreuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setreuid(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setreuid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setreuid(x, arg2);
|
|
}
|
|
|
|
void test__setreuid__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setreuid(arg1, x);
|
|
}
|
|
|
|
void test__setfsuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setfsuid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setfsuid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
setfsuid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setfsuid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setfsuid(x);
|
|
}
|
|
|
|
void test__setfsgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setfsgid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setfsgid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
setfsgid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setfsgid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setfsgid(x);
|
|
}
|
|
|
|
void test__setsid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setsid();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getwd__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getwd(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getwd__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getwd(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getwd__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getwd(NULL);
|
|
}
|
|
|
|
void test__htonl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
htonl(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__htonl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
htonl(x);
|
|
}
|
|
|
|
void test__htons__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
htons(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__htons__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
htons(x);
|
|
}
|
|
|
|
void test__ntohl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ntohl(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ntohl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ntohl(x);
|
|
}
|
|
|
|
void test__ntohs__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ntohs(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ntohs__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ntohs(x);
|
|
}
|
|
|
|
void test__mq_close__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_close(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_close__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_close(x);
|
|
}
|
|
|
|
void test__mq_getattr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_getattr(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_getattr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_getattr(x, arg2);
|
|
}
|
|
|
|
void test__mq_notify__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_notify(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_notify__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
mq_notify(NULL, arg2);
|
|
}
|
|
|
|
void test__mq_notify__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
mq_notify(x, arg2);
|
|
}
|
|
|
|
void test__mq_open__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_open();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_receive__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_receive(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_receive__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_receive(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__mq_send__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_send(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_send__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_send(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__mq_setattr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_setattr(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_setattr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_setattr(x, arg2, arg3);
|
|
}
|
|
|
|
void test__mq_timedreceive__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_timedreceive(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_timedreceive__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_timedreceive(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__mq_timedsend__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_timedsend(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_timedsend__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
mq_timedsend(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__mq_unlink__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
mq_unlink(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__mq_unlink__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
mq_unlink(NULL);
|
|
}
|
|
|
|
void test__mq_unlink__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
mq_unlink(x);
|
|
}
|
|
|
|
void test__dbm_clearerr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
dbm_clearerr(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_clearerr__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
dbm_clearerr(NULL);
|
|
}
|
|
|
|
void test__dbm_clearerr__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
dbm_clearerr(x);
|
|
}
|
|
|
|
void test__dbm_close__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
dbm_close(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_close__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
dbm_close(NULL);
|
|
}
|
|
|
|
void test__dbm_close__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
dbm_close(x);
|
|
}
|
|
|
|
void test__dbm_delete__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
dbm_delete(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_delete__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
dbm_delete(NULL, arg2);
|
|
}
|
|
|
|
void test__dbm_delete__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
dbm_delete(x, arg2);
|
|
}
|
|
|
|
void test__dbm_delete__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_delete(arg1, x);
|
|
}
|
|
|
|
void test__dbm_error__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = dbm_error(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_error__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
dbm_error(arg1);
|
|
}
|
|
|
|
void test__dbm_error__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = dbm_error(NULL);
|
|
}
|
|
|
|
void test__dbm_error__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = dbm_error(x);
|
|
}
|
|
|
|
void test__dbm_fetch__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = dbm_fetch(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_fetch__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
dbm_fetch(arg1, arg2);
|
|
}
|
|
|
|
void test__dbm_fetch__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = dbm_fetch(NULL, arg2);
|
|
}
|
|
|
|
void test__dbm_fetch__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = dbm_fetch(x, arg2);
|
|
}
|
|
|
|
void test__dbm_fetch__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = dbm_fetch(arg1, x);
|
|
}
|
|
|
|
void test__dbm_firstkey__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = dbm_firstkey(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_firstkey__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
dbm_firstkey(arg1);
|
|
}
|
|
|
|
void test__dbm_firstkey__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = dbm_firstkey(NULL);
|
|
}
|
|
|
|
void test__dbm_firstkey__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = dbm_firstkey(x);
|
|
}
|
|
|
|
void test__dbm_nextkey__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = dbm_nextkey(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_nextkey__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
dbm_nextkey(arg1);
|
|
}
|
|
|
|
void test__dbm_nextkey__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = dbm_nextkey(NULL);
|
|
}
|
|
|
|
void test__dbm_nextkey__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = dbm_nextkey(x);
|
|
}
|
|
|
|
void test__dbm_open__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
dbm_open(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_open__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
dbm_open(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__dbm_open__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
dbm_open(x, arg2, arg3);
|
|
}
|
|
|
|
void test__dbm_open__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_open(arg1, x, arg3);
|
|
}
|
|
|
|
void test__dbm_open__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_open(arg1, arg2, x);
|
|
}
|
|
|
|
void test__dbm_store__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
dbm_store(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__dbm_store__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
dbm_store(NULL, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__dbm_store__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
dbm_store(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__dbm_store__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_store(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__dbm_store__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_store(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__dbm_store__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
dbm_store(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__freeaddrinfo__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
freeaddrinfo(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__freeaddrinfo__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
freeaddrinfo(NULL);
|
|
}
|
|
|
|
void test__freeaddrinfo__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
freeaddrinfo(x);
|
|
}
|
|
|
|
void test__getaddrinfo__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getaddrinfo(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getaddrinfo__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getaddrinfo(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__getaddrinfo__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getaddrinfo(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__getaddrinfo__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getaddrinfo(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__getaddrinfo__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getaddrinfo(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__endhostent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
endhostent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sethostent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sethostent(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sethostent__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sethostent(x);
|
|
}
|
|
|
|
void test__uname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
uname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__uname__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
uname(NULL);
|
|
}
|
|
|
|
void test__endpwent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
endpwent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpwent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpwent();
|
|
}
|
|
|
|
void test__getpwnam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpwnam(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwnam__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpwnam(arg1);
|
|
}
|
|
|
|
void test__getpwnam__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getpwnam(x);
|
|
}
|
|
|
|
void test__strtok_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
strtok_r(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strtok_r__pure(int arg1,int arg2,int arg3)
|
|
{
|
|
// cppcheck-suppress incorrectLogicOperator
|
|
if ((strtok_r(arg1, arg2, arg3) > 10) || (strtok_r(arg1, arg2, arg3) < 100)) {}
|
|
}
|
|
|
|
void test__strtok_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
strtok_r(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__strtok_r__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
strtok_r(x, arg2, arg3);
|
|
}
|
|
|
|
void test__strtok_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strtok_r(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__strtok_r__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
strtok_r(arg1, x, arg3);
|
|
}
|
|
|
|
void test__strtok_r__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
strtok_r(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__getpwnam_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpwnam_r(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwnam_r__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpwnam_r(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__getpwnam_r__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getpwnam_r(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__getpwnam_r__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getpwnam_r(arg1, arg2, arg3, x, arg5);
|
|
}
|
|
|
|
void test__getpwuid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getpwuid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwuid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getpwuid(arg1);
|
|
}
|
|
|
|
void test__getpwuid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getpwuid(x);
|
|
}
|
|
|
|
void test__getpwuid_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getpwuid_r(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpwuid_r__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getpwuid_r(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__getpwuid_r__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getpwuid_r(arg1, arg2, arg3, x, arg5);
|
|
}
|
|
|
|
void test__setpwent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setpwent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__catclose__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
catclose(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__catclose__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
catclose(x);
|
|
}
|
|
|
|
void test__catgets__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = catgets(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__catgets__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
catgets(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__catgets__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = catgets(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__catgets__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = catgets(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__catgets__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = catgets(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__catgets__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = catgets(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__catopen__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
catopen(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__catopen__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
catopen(NULL, arg2);
|
|
}
|
|
|
|
void test__catopen__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
catopen(x, arg2);
|
|
}
|
|
|
|
void test__catopen__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
catopen(arg1, x);
|
|
}
|
|
|
|
void test__poll__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
poll(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__poll__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
poll(x, arg2, arg3);
|
|
}
|
|
|
|
void test__poll__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
poll(arg1, x, arg3);
|
|
}
|
|
|
|
void test__poll__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
poll(arg1, arg2, x);
|
|
}
|
|
|
|
void test__regcomp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
regcomp(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__regcomp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
regcomp(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__regcomp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regcomp(arg1, x, arg3);
|
|
}
|
|
|
|
void test__regcomp__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regcomp(arg1, arg2, x);
|
|
}
|
|
|
|
void test__regerror__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
regerror(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__regerror__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regerror(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__regerror__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regerror(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__regerror__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regerror(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__regexec__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
regexec(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__regexec__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
regexec(NULL, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__regexec__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
regexec(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__regexec__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
regexec(arg1, NULL, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__regexec__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
regexec(arg1, x, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__regexec__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regexec(arg1, arg2, x, arg4, arg5);
|
|
}
|
|
|
|
void test__regexec__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regexec(arg1, arg2, arg3, x, arg5);
|
|
}
|
|
|
|
void test__regexec__arg5__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
regexec(arg1, arg2, arg3, arg4, x);
|
|
}
|
|
|
|
void test__regfree__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
regfree(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__regfree__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
regfree(NULL);
|
|
}
|
|
|
|
void test__regfree__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
regfree(x);
|
|
}
|
|
|
|
void test__sched_get_priority_max__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_get_priority_max(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_get_priority_max__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_get_priority_max(x);
|
|
}
|
|
|
|
void test__sched_get_priority_min__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_get_priority_min(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_get_priority_min__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_get_priority_min(x);
|
|
}
|
|
|
|
void test__sched_getparam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_getparam(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_getparam__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_getparam(x, arg2);
|
|
}
|
|
|
|
void test__sched_getparam__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sched_getparam(arg1, NULL);
|
|
}
|
|
|
|
void test__sched_getscheduler__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_getscheduler(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_getscheduler__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_getscheduler(x);
|
|
}
|
|
|
|
void test__sched_rr_get_interval__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_rr_get_interval(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_rr_get_interval__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_rr_get_interval(x, arg2);
|
|
}
|
|
|
|
void test__sched_rr_get_interval__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sched_rr_get_interval(arg1, NULL);
|
|
}
|
|
|
|
void test__sched_setparam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_setparam(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_setparam__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_setparam(x, arg2);
|
|
}
|
|
|
|
void test__sched_setparam__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_setparam(arg1, x);
|
|
}
|
|
|
|
void test__sched_setscheduler__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_setscheduler(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sched_setscheduler__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_setscheduler(x, arg2, arg3);
|
|
}
|
|
|
|
void test__sched_setscheduler__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_setscheduler(arg1, x, arg3);
|
|
}
|
|
|
|
void test__sched_setscheduler__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sched_setscheduler(arg1, arg2, x);
|
|
}
|
|
|
|
void test__sched_yield__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sched_yield();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ecvt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ecvt(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ecvt__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ecvt(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__ecvt__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ecvt(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__ecvt__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
ecvt(arg1, arg2, NULL, arg4);
|
|
}
|
|
|
|
void test__ecvt__arg4__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
ecvt(arg1, arg2, arg3, NULL);
|
|
}
|
|
|
|
void test__fcvt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fcvt(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fcvt__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fcvt(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__fcvt__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fcvt(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__fcvt__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
fcvt(arg1, arg2, NULL, arg4);
|
|
}
|
|
|
|
void test__fcvt__arg4__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
fcvt(arg1, arg2, arg3, NULL);
|
|
}
|
|
|
|
void test__gcvt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
gcvt(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gcvt__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
gcvt(x, arg2, arg3);
|
|
}
|
|
|
|
void test__gcvt__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
gcvt(arg1, x, arg3);
|
|
}
|
|
|
|
void test__gcvt__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
gcvt(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__lseek__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
lseek(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__lseek__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
lseek(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__lseek__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
lseek(x, arg2, arg3);
|
|
}
|
|
|
|
void test__lseek__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
lseek(arg1, x, arg3);
|
|
}
|
|
|
|
void test__lseek__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
lseek(arg1, arg2, x);
|
|
}
|
|
|
|
void test__nanosleep__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
nanosleep(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__nanosleep__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
nanosleep(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__nanosleep__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
nanosleep(NULL, arg2);
|
|
}
|
|
|
|
void test__setkey__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setkey(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setkey__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
setkey(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setkey__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
setkey(NULL);
|
|
}
|
|
|
|
void test__setkey__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
setkey(x);
|
|
}
|
|
|
|
void test__getpass__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getpass(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getpass__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getpass(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getpass__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getpass(NULL);
|
|
}
|
|
|
|
void test__drand48__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = drand48();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__drand48__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
drand48();
|
|
}
|
|
|
|
void test__putenv__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
putenv(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__putenv__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
putenv(NULL);
|
|
}
|
|
|
|
void test__putenv__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
putenv(x);
|
|
}
|
|
|
|
void test__setenv__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setenv(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setenv__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
setenv(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__setenv__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
setenv(x, arg2, arg3);
|
|
}
|
|
|
|
void test__setenv__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
setenv(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__setenv__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
setenv(arg1, x, arg3);
|
|
}
|
|
|
|
void test__setenv__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setenv(arg1, arg2, x);
|
|
}
|
|
|
|
void test__unsetenv__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
unsetenv(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__unsetenv__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
unsetenv(NULL);
|
|
}
|
|
|
|
void test__unsetenv__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
unsetenv(x);
|
|
}
|
|
|
|
void test__localtime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
localtime(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__localtime__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
localtime(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__localtime__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
localtime(NULL);
|
|
}
|
|
|
|
void test__localtime__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
localtime(x);
|
|
}
|
|
|
|
void test__std__localtime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
std::localtime(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__std__localtime__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
std::localtime(NULL);
|
|
}
|
|
|
|
void test__std__localtime__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
std::localtime(x);
|
|
}
|
|
|
|
void test__localtime_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
localtime_r(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__localtime_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
localtime_r(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__localtime_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
localtime_r(NULL, arg2);
|
|
}
|
|
|
|
void test__localtime_r__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
localtime_r(x, arg2);
|
|
}
|
|
|
|
void test__localtime_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
localtime_r(arg1, NULL);
|
|
}
|
|
|
|
void test__readdir__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
readdir(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__readdir__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
readdir(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__readdir__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readdir(NULL);
|
|
}
|
|
|
|
void test__readdir__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
readdir(x);
|
|
}
|
|
|
|
void test__readdir_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
readdir_r(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__readdir_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
readdir_r(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__readdir_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readdir_r(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__readdir_r__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
readdir_r(x, arg2, arg3);
|
|
}
|
|
|
|
void test__readdir_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readdir_r(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__readdir_r__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readdir_r(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__readlink__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
readlink(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__readlink__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
readlink(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__readlink__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readlink(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__readlink__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
readlink(x, arg2, arg3);
|
|
}
|
|
|
|
void test__readlink__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readlink(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__readlink__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
readlink(arg1, arg2, x);
|
|
}
|
|
|
|
void test__readlinkat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
readlinkat(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__readlinkat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
readlinkat(p, arg2, arg3, arg4);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__readlinkat__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
readlinkat(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__readlinkat__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readlinkat(arg1, NULL, arg3, arg4);
|
|
}
|
|
|
|
void test__readlinkat__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
readlinkat(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__readlinkat__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
readlinkat(arg1, arg2, NULL, arg4);
|
|
}
|
|
|
|
void test__readlinkat__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
readlinkat(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__asctime_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
asctime_r(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__asctime_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
asctime_r(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__asctime_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
asctime_r(NULL, arg2);
|
|
}
|
|
|
|
void test__asctime_r__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
asctime_r(x, arg2);
|
|
}
|
|
|
|
void test__asctime_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
asctime_r(arg1, NULL);
|
|
}
|
|
|
|
void test__ctime_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ctime_r(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ctime_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ctime_r(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ctime_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
ctime_r(NULL, arg2);
|
|
}
|
|
|
|
void test__ctime_r__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
ctime_r(x, arg2);
|
|
}
|
|
|
|
void test__ctime_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
ctime_r(arg1, NULL);
|
|
}
|
|
|
|
void test__gmtime_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
gmtime_r(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gmtime_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
gmtime_r(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gmtime_r__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
gmtime_r(NULL, arg2);
|
|
}
|
|
|
|
void test__gmtime_r__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
gmtime_r(x, arg2);
|
|
}
|
|
|
|
void test__gmtime_r__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
gmtime_r(arg1, NULL);
|
|
}
|
|
|
|
void test__gmtime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = gmtime(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__gmtime__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
gmtime(arg1);
|
|
}
|
|
|
|
void test__gmtime__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = gmtime(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__gmtime__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = gmtime(NULL);
|
|
}
|
|
|
|
void test__gmtime__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = gmtime(x);
|
|
}
|
|
|
|
void test__clock_settime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
clock_settime(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__clock_settime__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
clock_settime(x, arg2);
|
|
}
|
|
|
|
void test__clock_settime__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
clock_settime(arg1, x);
|
|
}
|
|
|
|
void test__killpg__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
killpg(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__killpg__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
killpg(x, arg2);
|
|
}
|
|
|
|
void test__killpg__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
killpg(arg1, x);
|
|
}
|
|
|
|
void test__kill__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
kill(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__kill__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
kill(x, arg2);
|
|
}
|
|
|
|
void test__kill__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
kill(arg1, x);
|
|
}
|
|
|
|
void test__clock_gettime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
clock_gettime(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__clock_gettime__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
clock_gettime(x, arg2);
|
|
}
|
|
|
|
void test__clock_gettime__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
clock_gettime(arg1, NULL);
|
|
}
|
|
|
|
void test__clock_getres__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
clock_getres(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__clock_getres__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
clock_getres(x, arg2);
|
|
}
|
|
|
|
void test__tmpnam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tmpnam(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tmpnam__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tmpnam(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tmpnam__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tmpnam(x);
|
|
}
|
|
|
|
void test__tmpnam_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tmpnam_r(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tmpnam_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tmpnam_r(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tmpnam_r__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tmpnam_r(x);
|
|
}
|
|
|
|
void test__makecontext__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
makecontext(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__makecontext__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
makecontext(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__makecontext__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
makecontext(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__makecontext__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
makecontext(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__makecontext__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
makecontext(arg1, x, arg3);
|
|
}
|
|
|
|
void test__makecontext__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
makecontext(arg1, arg2, x);
|
|
}
|
|
|
|
void test__swapcontext__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
swapcontext(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__swapcontext__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
swapcontext(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__swapcontext__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
swapcontext(NULL, arg2);
|
|
}
|
|
|
|
void test__swapcontext__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
swapcontext(arg1, NULL);
|
|
}
|
|
|
|
void test__getcontext__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getcontext(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getcontext__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getcontext(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getcontext__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getcontext(NULL);
|
|
}
|
|
|
|
void test__ualarm__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ualarm(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ualarm__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ualarm(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ualarm__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ualarm(x, arg2);
|
|
}
|
|
|
|
void test__ualarm__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ualarm(arg1, x);
|
|
}
|
|
|
|
void test__scalb__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = scalb(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__scalb__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
scalb(arg1, arg2);
|
|
}
|
|
|
|
void test__scalb__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = scalb(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__scalb__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = scalb(x, arg2);
|
|
}
|
|
|
|
void test__scalb__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = scalb(arg1, x);
|
|
}
|
|
|
|
void test__bcopy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
bcopy(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__bcopy__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
bcopy(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__bcopy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
bcopy(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__bcopy__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
bcopy(x, arg2, arg3);
|
|
}
|
|
|
|
void test__bcopy__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
bcopy(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__bcopy__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
bcopy(arg1, arg2, x);
|
|
}
|
|
|
|
void test__bcmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = bcmp(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__bcmp__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
bcmp(arg1, arg2, arg3);
|
|
}
|
|
|
|
void test__bcmp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = bcmp(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__bcmp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = bcmp(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__bcmp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = bcmp(x, arg2, arg3);
|
|
}
|
|
|
|
void test__bcmp__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = bcmp(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__bcmp__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = bcmp(arg1, x, arg3);
|
|
}
|
|
|
|
void test__bcmp__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = bcmp(arg1, arg2, x);
|
|
}
|
|
|
|
void test__bzero__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
bzero(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__bzero__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
bzero(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__bzero__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
bzero(NULL, arg2);
|
|
}
|
|
|
|
void test__bzero__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
bzero(arg1, x);
|
|
}
|
|
|
|
void test__ftime__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ftime(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ftime__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ftime(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ftime__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
ftime(x);
|
|
}
|
|
|
|
void test__wcswcs__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = wcswcs(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__wcswcs__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
wcswcs(arg1, arg2);
|
|
}
|
|
|
|
void test__wcswcs__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = wcswcs(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__wcswcs__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = wcswcs(NULL, arg2);
|
|
}
|
|
|
|
void test__wcswcs__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = wcswcs(x, arg2);
|
|
}
|
|
|
|
void test__wcswcs__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = wcswcs(arg1, NULL);
|
|
}
|
|
|
|
void test__wcswcs__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = wcswcs(arg1, x);
|
|
}
|
|
|
|
void test__stpcpy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
stpcpy(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__stpcpy__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
stpcpy(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__stpcpy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stpcpy(NULL, arg2);
|
|
}
|
|
|
|
void test__stpcpy__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stpcpy(arg1, NULL);
|
|
}
|
|
|
|
void test__stpcpy__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
stpcpy(arg1, x);
|
|
}
|
|
|
|
void test__index__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = index(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__index__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
index(arg1, arg2);
|
|
}
|
|
|
|
void test__index__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = index(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__index__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = index(NULL, arg2);
|
|
}
|
|
|
|
void test__index__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = index(x, arg2);
|
|
}
|
|
|
|
void test__index__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = index(arg1, x);
|
|
}
|
|
|
|
void test__rindex__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = rindex(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__rindex__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
rindex(arg1, arg2);
|
|
}
|
|
|
|
void test__rindex__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = rindex(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__rindex__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = rindex(NULL, arg2);
|
|
}
|
|
|
|
void test__rindex__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = rindex(x, arg2);
|
|
}
|
|
|
|
void test__rindex__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = rindex(arg1, x);
|
|
}
|
|
|
|
void test__bsd_signal__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
bsd_signal(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__bsd_signal__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
bsd_signal(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__bsd_signal__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
bsd_signal(x, arg2);
|
|
}
|
|
|
|
void test__bsd_signal__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
bsd_signal(arg1, x);
|
|
}
|
|
|
|
void test__fork__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fork();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fork__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fork();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__vfork__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
vfork();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__vfork__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
vfork();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__pthread_atfork__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_atfork(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_atfork__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
pthread_atfork(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__pthread_create__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_create(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_create__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_create(NULL, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__pthread_create__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_create(arg1, arg2, NULL, arg4);
|
|
}
|
|
|
|
void test__pthread_detach__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_detach(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_detach__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_detach(x);
|
|
}
|
|
|
|
void test__pthread_equal__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = pthread_equal(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_equal__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
pthread_equal(arg1, arg2);
|
|
}
|
|
|
|
void test__pthread_equal__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = pthread_equal(x, arg2);
|
|
}
|
|
|
|
void test__pthread_equal__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = pthread_equal(arg1, x);
|
|
}
|
|
|
|
void test__pthread_exit__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_exit(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_join__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_join(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_join__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_join(x, arg2);
|
|
}
|
|
|
|
void test__pthread_kill__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_kill(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_kill__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_kill(x, arg2);
|
|
}
|
|
|
|
void test__pthread_kill__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_kill(arg1, x);
|
|
}
|
|
|
|
void test__pthread_self__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = pthread_self();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_self__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
pthread_self();
|
|
}
|
|
|
|
void test__pthread_attr_destroy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_attr_destroy(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_attr_destroy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_destroy(NULL);
|
|
}
|
|
|
|
void test__pthread_attr_init__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_attr_init(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_attr_init__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_init(NULL);
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_attr_setstackaddr(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
pthread_attr_setstackaddr(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_setstackaddr(NULL, arg2);
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
pthread_attr_setstackaddr(x, arg2);
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_setstackaddr(arg1, NULL);
|
|
}
|
|
|
|
void test__pthread_attr_setstackaddr__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
pthread_attr_setstackaddr(arg1, x);
|
|
}
|
|
|
|
void test__pthread_attr_getstackaddr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_attr_getstackaddr(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_attr_getstackaddr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
pthread_attr_getstackaddr(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__pthread_attr_getstackaddr__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_getstackaddr(NULL, arg2);
|
|
}
|
|
|
|
void test__pthread_attr_getstackaddr__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
pthread_attr_getstackaddr(x, arg2);
|
|
}
|
|
|
|
void test__pthread_attr_getstackaddr__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
pthread_attr_getstackaddr(arg1, NULL);
|
|
}
|
|
|
|
void test__tempnam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = tempnam(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tempnam__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
tempnam(arg1, arg2);
|
|
}
|
|
|
|
void test__tempnam__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = tempnam(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tempnam__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = tempnam(x, arg2);
|
|
}
|
|
|
|
void test__tempnam__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = tempnam(arg1, x);
|
|
}
|
|
|
|
void test__crypt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = crypt(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__crypt__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
crypt(arg1, arg2);
|
|
}
|
|
|
|
void test__crypt__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = crypt(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__crypt__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = crypt(NULL, arg2);
|
|
}
|
|
|
|
void test__crypt__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = crypt(x, arg2);
|
|
}
|
|
|
|
void test__crypt__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = crypt(arg1, NULL);
|
|
}
|
|
|
|
void test__crypt__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = crypt(arg1, x);
|
|
}
|
|
|
|
void test__ttyname__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = ttyname(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ttyname__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
ttyname(arg1);
|
|
}
|
|
|
|
void test__ttyname__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = ttyname(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ttyname__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = ttyname(x);
|
|
}
|
|
|
|
void test__getspnam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getspnam(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getspnam__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getspnam(arg1);
|
|
}
|
|
|
|
void test__getspnam__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getspnam(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getspnam__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getspnam(NULL);
|
|
}
|
|
|
|
void test__getspnam__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getspnam(x);
|
|
}
|
|
|
|
void test__getspent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getspent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getspent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getspent();
|
|
}
|
|
|
|
void test__getspent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getspent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fgetspent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fgetspent(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fgetspent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fgetspent(arg1);
|
|
}
|
|
|
|
void test__fgetspent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = fgetspent(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fgetspent__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fgetspent(NULL);
|
|
}
|
|
|
|
void test__fgetspent__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fgetspent(x);
|
|
}
|
|
|
|
void test__sgetspent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = sgetspent(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sgetspent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
sgetspent(arg1);
|
|
}
|
|
|
|
void test__sgetspent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = sgetspent(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sgetspent__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = sgetspent(NULL);
|
|
}
|
|
|
|
void test__sgetspent__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = sgetspent(x);
|
|
}
|
|
|
|
void test__fgetpwent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fgetpwent(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fgetpwent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fgetpwent(arg1);
|
|
}
|
|
|
|
void test__fgetpwent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = fgetpwent(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fgetpwent__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fgetpwent(NULL);
|
|
}
|
|
|
|
void test__fgetpwent__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fgetpwent(x);
|
|
}
|
|
|
|
void test__getgrent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getgrent();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getgrent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getgrent();
|
|
}
|
|
|
|
void test__getgrent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getgrent();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getgrent_r__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getgrent_r(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getgrent_r__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getgrent_r(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__getgrent_r__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getgrent_r(p, arg2, arg3, arg4);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getgrent_r__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getgrent_r(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__getgrent_r__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getgrent_r(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__fgetgrent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fgetgrent(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fgetgrent__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fgetgrent(arg1);
|
|
}
|
|
|
|
void test__fgetgrent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = fgetgrent(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fgetgrent__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fgetgrent(NULL);
|
|
}
|
|
|
|
void test__fgetgrent__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fgetgrent(x);
|
|
}
|
|
|
|
void test__getnetgrent__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getnetgrent(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getnetgrent__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getnetgrent(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getnetgrent__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getnetgrent(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__getnetgrent__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getnetgrent(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__getnetgrent__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getnetgrent(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__getgrnam__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getgrnam(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getgrnam__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getgrnam(arg1);
|
|
}
|
|
|
|
void test__getgrnam__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getgrnam(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getgrnam__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = getgrnam(NULL);
|
|
}
|
|
|
|
void test__getgrnam__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = getgrnam(x);
|
|
}
|
|
|
|
void test__getgrgid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getgrgid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getgrgid__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getgrgid(arg1);
|
|
}
|
|
|
|
void test__getgrgid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getgrgid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getgrgid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = getgrgid(x);
|
|
}
|
|
|
|
void test__getlogin__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = getlogin();
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getlogin__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
getlogin();
|
|
}
|
|
|
|
void test__getlogin__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = getlogin();
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ctermid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
ctermid(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ctermid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
ctermid(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__realpath__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
realpath(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__realpath__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
realpath(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__realpath__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
realpath(NULL, arg2);
|
|
}
|
|
|
|
void test__realpath__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
realpath(x, arg2);
|
|
}
|
|
|
|
void test__remove__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
remove(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__remove__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
remove(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__remove__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
remove(NULL);
|
|
}
|
|
|
|
void test__remove__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
remove(x);
|
|
}
|
|
|
|
void test__fileno__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = fileno(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fileno__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
fileno(arg1);
|
|
}
|
|
|
|
void test__fileno__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = fileno(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fileno__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = fileno(NULL);
|
|
}
|
|
|
|
void test__fileno__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = fileno(x);
|
|
}
|
|
|
|
void test__fseeko__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
fseeko(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__fseeko__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
fseeko(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__fseeko__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
fseeko(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__fseeko__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
fseeko(x, arg2, arg3);
|
|
}
|
|
|
|
void test__fseeko__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fseeko(arg1, x, arg3);
|
|
}
|
|
|
|
void test__fseeko__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
fseeko(arg1, arg2, x);
|
|
}
|
|
|
|
void test__ftello__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = ftello(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ftello__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
ftello(arg1);
|
|
}
|
|
|
|
void test__ftello__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = ftello(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ftello__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = ftello(NULL);
|
|
}
|
|
|
|
void test__ftello__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = ftello(x);
|
|
}
|
|
|
|
void test__execv__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
execv(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__execv__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
execv(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__execv__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
execv(NULL, arg2);
|
|
}
|
|
|
|
void test__execv__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
execv(x, arg2);
|
|
}
|
|
|
|
void test__execv__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
execv(arg1, x);
|
|
}
|
|
|
|
void test__execvp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
execvp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__execvp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
execvp(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__execvp__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
execvp(NULL, arg2);
|
|
}
|
|
|
|
void test__execvp__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
execvp(x, arg2);
|
|
}
|
|
|
|
void test__execvp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
execvp(arg1, x);
|
|
}
|
|
|
|
void test__wait__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
wait(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__wait__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
wait(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__waitpid__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
waitpid(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__waitpid__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
waitpid(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__waitpid__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
waitpid(x, arg2, arg3);
|
|
}
|
|
|
|
void test__waitpid__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
waitpid(arg1, arg2, x);
|
|
}
|
|
|
|
void test__strnlen__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = strnlen(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__strnlen__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
strnlen(arg1, arg2);
|
|
}
|
|
|
|
void test__strnlen__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = strnlen(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__strnlen__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = strnlen(NULL, arg2);
|
|
}
|
|
|
|
void test__strnlen__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = strnlen(x, arg2);
|
|
}
|
|
|
|
void test__strnlen__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = strnlen(arg1, x);
|
|
}
|
|
|
|
void test__wcsnlen__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = wcsnlen(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__wcsnlen__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
wcsnlen(arg1, arg2);
|
|
}
|
|
|
|
void test__wcsnlen__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = wcsnlen(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__wcsnlen__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
result = wcsnlen(NULL, arg2);
|
|
}
|
|
|
|
void test__wcsnlen__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
result = wcsnlen(x, arg2);
|
|
}
|
|
|
|
void test__wcsnlen__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = wcsnlen(arg1, x);
|
|
}
|
|
|
|
void test__ffs__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = ffs(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__ffs__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
ffs(arg1);
|
|
}
|
|
|
|
void test__ffs__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
result = ffs(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__ffs__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = ffs(x);
|
|
}
|
|
|
|
void test__shmctl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
shmctl(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__shmctl__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
shmctl(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__shmctl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmctl(x, arg2);
|
|
}
|
|
|
|
void test__shmctl__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmctl(arg1, x);
|
|
}
|
|
|
|
void test__shmget__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
shmget(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__shmget__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
shmget(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__shmget__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmget(x, arg2, arg3);
|
|
}
|
|
|
|
void test__shmget__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmget(arg1, x, arg3);
|
|
}
|
|
|
|
void test__shmget__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmget(arg1, arg2, x);
|
|
}
|
|
|
|
void test__shmat__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
shmat(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__shmat__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
shmat(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__shmat__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmat(x, arg2, arg3);
|
|
}
|
|
|
|
void test__shmat__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
shmat(arg1, arg2, x);
|
|
}
|
|
|
|
void test__shmdt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
shmdt(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__shmdt__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
shmdt(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrlimit__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getrlimit(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getrlimit__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getrlimit(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrlimit__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getrlimit(x, arg2);
|
|
}
|
|
|
|
void test__getrlimit__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getrlimit(arg1, NULL);
|
|
}
|
|
|
|
void test__setrlimit__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setrlimit(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setrlimit__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
setrlimit(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setrlimit__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setrlimit(x, arg2);
|
|
}
|
|
|
|
void test__setrlimit__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
setrlimit(arg1, NULL);
|
|
}
|
|
|
|
void test__setrlimit__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
setrlimit(arg1, x);
|
|
}
|
|
|
|
void test__glob__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
glob(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__glob__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
glob(NULL, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__glob__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
glob(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__glob__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
glob(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__glob__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
glob(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__glob__arg4__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
glob(arg1, arg2, arg3, NULL);
|
|
}
|
|
|
|
void test__globfree__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
globfree(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__globfree__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
globfree(NULL);
|
|
}
|
|
|
|
void test__globfree__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
globfree(x);
|
|
}
|
|
|
|
void test__wcpncpy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
wcpncpy(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__wcpncpy__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
wcpncpy(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__wcpncpy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
wcpncpy(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__wcpncpy__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
wcpncpy(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__wcpncpy__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
wcpncpy(arg1, x, arg3);
|
|
}
|
|
|
|
void test__wcpncpy__arg3__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
wcpncpy(arg1, arg2, !x);
|
|
}
|
|
|
|
void test__wcpncpy__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
wcpncpy(arg1, arg2, x);
|
|
}
|
|
|
|
void test__stpncpy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
stpncpy(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__stpncpy__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
stpncpy(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__stpncpy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stpncpy(NULL, arg2, arg3);
|
|
}
|
|
|
|
void test__stpncpy__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
stpncpy(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__stpncpy__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
stpncpy(arg1, x, arg3);
|
|
}
|
|
|
|
void test__stpncpy__arg3__notbool()
|
|
{
|
|
// cppcheck-suppress invalidFunctionArgBool
|
|
stpncpy(arg1, arg2, !x);
|
|
}
|
|
|
|
void test__stpncpy__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
stpncpy(arg1, arg2, x);
|
|
}
|
|
|
|
void test__memccpy__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
memccpy(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__memccpy__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
memccpy(p, arg2, arg3, arg4);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__memccpy__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
memccpy(NULL, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__memccpy__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
memccpy(arg1, NULL, arg3, arg4);
|
|
}
|
|
|
|
void test__memccpy__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
memccpy(arg1, x, arg3, arg4);
|
|
}
|
|
|
|
void test__memccpy__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
memccpy(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__memccpy__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
memccpy(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__getopt__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getopt(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getopt__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getopt(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getopt__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getopt(x, arg2, arg3);
|
|
}
|
|
|
|
void test__getopt__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getopt(arg1, NULL, arg3);
|
|
}
|
|
|
|
void test__getopt__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
getopt(arg1, x, arg3);
|
|
}
|
|
|
|
void test__getopt__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getopt(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__getopt__arg3__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
getopt(arg1, arg2, x);
|
|
}
|
|
|
|
void test__getitimer__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getitimer(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getitimer__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getitimer(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getitimer__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getitimer(x, arg2);
|
|
}
|
|
|
|
void test__getitimer__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getitimer(arg1, NULL);
|
|
}
|
|
|
|
void test__getitimer__arg2__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
getitimer(arg1, x);
|
|
}
|
|
|
|
void test__setitimer__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
setitimer(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__setitimer__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
setitimer(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__setitimer__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setitimer(x, arg2, arg3);
|
|
}
|
|
|
|
void test__setitimer__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setitimer(arg1, x, arg3);
|
|
}
|
|
|
|
void test__setitimer__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
setitimer(arg1, arg2, x);
|
|
}
|
|
|
|
void test__sigaction__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigaction(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigaction__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigaction(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigaction__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigaction(x, arg2, arg3);
|
|
}
|
|
|
|
void test__sigaltstack__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigaltstack(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigaltstack__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigaltstack(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigaltstack__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigaltstack(x, arg2);
|
|
}
|
|
|
|
void test__siglongjmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
siglongjmp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__siglongjmp__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
siglongjmp(x, arg2);
|
|
}
|
|
|
|
void test__siglongjmp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
siglongjmp(arg1, x);
|
|
}
|
|
|
|
void test___longjmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
_longjmp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test___longjmp__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
_longjmp(x, arg2);
|
|
}
|
|
|
|
void test___longjmp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
_longjmp(arg1, x);
|
|
}
|
|
|
|
void test__sigsetjmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigsetjmp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigsetjmp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigsetjmp(arg1, x);
|
|
}
|
|
|
|
void test___setjmp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
_setjmp(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test___setjmp__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
_setjmp(arg1, x);
|
|
}
|
|
|
|
void test__sigsuspend__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigsuspend(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigsuspend__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigsuspend(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigsuspend__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigsuspend(NULL);
|
|
}
|
|
|
|
void test__pthread_sigmask__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
pthread_sigmask(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__pthread_sigmask__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_sigmask(x, arg2, arg3);
|
|
}
|
|
|
|
void test__pthread_sigmask__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_sigmask(arg1, x, arg3);
|
|
}
|
|
|
|
void test__pthread_sigmask__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
pthread_sigmask(arg1, arg2, x);
|
|
}
|
|
|
|
void test__sigprocmask__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigprocmask(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigprocmask__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigprocmask(x, arg2, arg3);
|
|
}
|
|
|
|
void test__sigprocmask__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigprocmask(arg1, x, arg3);
|
|
}
|
|
|
|
void test__sigprocmask__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigprocmask(arg1, arg2, x);
|
|
}
|
|
|
|
void test__getrusage__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
getrusage(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__getrusage__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
getrusage(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__getrusage__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
getrusage(x, arg2);
|
|
}
|
|
|
|
void test__getrusage__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
getrusage(arg1, NULL);
|
|
}
|
|
|
|
void test__sigemptyset__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigemptyset(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigemptyset__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigemptyset(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigemptyset__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigemptyset(NULL);
|
|
}
|
|
|
|
void test__sigfillset__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigfillset(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigfillset__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigfillset(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigfillset__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigfillset(NULL);
|
|
}
|
|
|
|
void test__sigaddset__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigaddset(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigaddset__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigaddset(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigaddset__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigaddset(NULL, arg2);
|
|
}
|
|
|
|
void test__sigaddset__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigaddset(arg1, x);
|
|
}
|
|
|
|
void test__sigdelset__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigdelset(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigdelset__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigdelset(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigdelset__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigdelset(NULL, arg2);
|
|
}
|
|
|
|
void test__sigdelset__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigdelset(arg1, x);
|
|
}
|
|
|
|
void test__sigismember__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
sigismember(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__sigismember__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
sigismember(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__sigismember__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
sigismember(NULL, arg2);
|
|
}
|
|
|
|
void test__sigismember__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
sigismember(arg1, x);
|
|
}
|
|
|
|
void test__posix_spawn__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
posix_spawn(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__posix_spawn__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__posix_spawnp__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
posix_spawnp(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__posix_spawnp__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__msgctl__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
msgctl(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__msgctl__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
msgctl(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__msgctl__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgctl(x, arg2, arg3);
|
|
}
|
|
|
|
void test__msgctl__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgctl(arg1, x, arg3);
|
|
}
|
|
|
|
void test__msgctl__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgctl(arg1, arg2, x);
|
|
}
|
|
|
|
void test__msgget__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
result = msgget(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__msgget__useretval()
|
|
{
|
|
// cppcheck-suppress ignoredReturnValue
|
|
msgget(arg1, arg2);
|
|
}
|
|
|
|
void test__msgget__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = msgget(x, arg2);
|
|
}
|
|
|
|
void test__msgget__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
result = msgget(arg1, x);
|
|
}
|
|
|
|
void test__msgrcv__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
msgrcv(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__msgrcv__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
msgrcv(p, arg2, arg3, arg4, arg5);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__msgrcv__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgrcv(x, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__msgrcv__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
msgrcv(arg1, NULL, arg3, arg4, arg5);
|
|
}
|
|
|
|
void test__msgrcv__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgrcv(arg1, arg2, x, arg4, arg5);
|
|
}
|
|
|
|
void test__msgrcv__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgrcv(arg1, arg2, arg3, x, arg5);
|
|
}
|
|
|
|
void test__msgrcv__arg5__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgrcv(arg1, arg2, arg3, arg4, x);
|
|
}
|
|
|
|
void test__msgsnd__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
msgsnd(arg1, arg2, arg3, arg4);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__msgsnd__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
msgsnd(p, arg2, arg3, arg4);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__msgsnd__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgsnd(x, arg2, arg3, arg4);
|
|
}
|
|
|
|
void test__msgsnd__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
msgsnd(arg1, NULL, arg3, arg4);
|
|
}
|
|
|
|
void test__msgsnd__arg3__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgsnd(arg1, arg2, x, arg4);
|
|
}
|
|
|
|
void test__msgsnd__arg4__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
msgsnd(arg1, arg2, arg3, x);
|
|
}
|
|
|
|
void test__tcflow__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcflow(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcflow__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcflow(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcflow__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcflow(x, arg2);
|
|
}
|
|
|
|
void test__tcflow__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcflow(arg1, x);
|
|
}
|
|
|
|
void test__tcflush__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcflush(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcflush__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcflush(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcflush__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcflush(x, arg2);
|
|
}
|
|
|
|
void test__tcflush__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcflush(arg1, x);
|
|
}
|
|
|
|
void test__tcsendbreak__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcsendbreak(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcsendbreak__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcsendbreak(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcsendbreak__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcsendbreak(x, arg2);
|
|
}
|
|
|
|
void test__tcsendbreak__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
tcsendbreak(arg1, NULL);
|
|
}
|
|
|
|
void test__tcgetattr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcgetattr(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcgetattr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcgetattr(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcgetattr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcgetattr(x, arg2);
|
|
}
|
|
|
|
void test__tcgetattr__arg2__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
tcgetattr(arg1, NULL);
|
|
}
|
|
|
|
void test__tcsetattr__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcsetattr(arg1, arg2, arg3);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcsetattr__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcsetattr(p, arg2, arg3);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcsetattr__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcsetattr(x, arg2, arg3);
|
|
}
|
|
|
|
void test__tcsetattr__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcsetattr(arg1, x, arg3);
|
|
}
|
|
|
|
void test__tcsetattr__arg3__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
tcsetattr(arg1, arg2, NULL);
|
|
}
|
|
|
|
void test__tcsetattr__arg3__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
tcsetattr(arg1, arg2, x);
|
|
}
|
|
|
|
void test__cfsetospeed__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
cfsetospeed(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__cfsetospeed__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
cfsetospeed(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__cfsetospeed__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
cfsetospeed(NULL, arg2);
|
|
}
|
|
|
|
void test__cfsetospeed__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
cfsetospeed(x, arg2);
|
|
}
|
|
|
|
void test__cfsetospeed__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
cfsetospeed(arg1, x);
|
|
}
|
|
|
|
void test__cfsetispeed__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
cfsetispeed(arg1, arg2);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__cfsetispeed__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
cfsetispeed(p, arg2);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__cfsetispeed__arg1__notnull()
|
|
{
|
|
// cppcheck-suppress nullPointer
|
|
cfsetispeed(NULL, arg2);
|
|
}
|
|
|
|
void test__cfsetispeed__arg1__notuninit()
|
|
{
|
|
int x[10];
|
|
// cppcheck-suppress uninitvar
|
|
cfsetispeed(x, arg2);
|
|
}
|
|
|
|
void test__cfsetispeed__arg2__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
cfsetispeed(arg1, x);
|
|
}
|
|
|
|
void test__tcdrain__noreturn()
|
|
{
|
|
int x = 1;
|
|
if (cond) {
|
|
x=100;
|
|
tcdrain(arg1);
|
|
}
|
|
// cppcheck-suppress shiftTooManyBits
|
|
x = 1 << x;
|
|
}
|
|
|
|
void test__tcdrain__leakignore()
|
|
{
|
|
char *p = malloc(10);
|
|
*p=0;
|
|
tcdrain(p);
|
|
// cppcheck-suppress memleak
|
|
}
|
|
|
|
void test__tcdrain__arg1__notuninit()
|
|
{
|
|
int x;
|
|
// cppcheck-suppress uninitvar
|
|
tcdrain(x);
|
|
}
|
|
|