cppcheck/test/cfg/generated-cfg-tests-wxwidgets.cpp

// auto generated tests from cfg/wxwidgets.cfg
//
// Generated by command:
// ./generate_cfg_tests cfg/wxwidgets.cfg > generated-cfg-tests-wxwidgets.cpp
//
// Recommended cppcheck command line:
// $ cppcheck --enable=warning,information --inline-suppr generated-cfg-tests-wxwidgets.cpp
// => 'unmatched suppression' warnings are false negatives.
//

void test__wxString__Format__noreturn() {
  int x = 100;
  if (cond) x=1; else wxString::Format(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Format__leakignore() {
  char *p = strdup(str);
  wxString::Format(p);
  // cppcheck-suppress memleak
}

void test__wxString__Format__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxString::Format(!x);
}

void test__wxString__Format__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxString::Format(NULL);
}

void test__wxString__Format__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxString::Format(x);
}

void test__wxString__Printf__noreturn() {
  int x = 100;
  if (cond) x=1; else wxString::Printf(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Printf__leakignore() {
  char *p = strdup(str);
  wxString::Printf(p);
  // cppcheck-suppress memleak
}

void test__wxString__Printf__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxString::Printf(!x);
}

void test__wxString__Printf__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxString::Printf(NULL);
}

void test__wxString__Printf__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxString::Printf(x);
}

void test__wxString__IsEmpty__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::IsEmpty();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__IsEmpty__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::IsEmpty();
}

void test__wxString__IsEmpty__leakignore() {
  char *p = strdup(str);
  result = wxString::IsEmpty();
  // cppcheck-suppress memleak
}

void test__wxString__IsNull__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::IsNull();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__IsNull__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::IsNull();
}

void test__wxString__IsNull__leakignore() {
  char *p = strdup(str);
  result = wxString::IsNull();
  // cppcheck-suppress memleak
}

void test__wxString__IsNumber__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::IsNumber();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__IsNumber__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::IsNumber();
}

void test__wxString__IsNumber__leakignore() {
  char *p = strdup(str);
  result = wxString::IsNumber();
  // cppcheck-suppress memleak
}

void test__wxString__IsAscii__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::IsAscii();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__IsAscii__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::IsAscii();
}

void test__wxString__IsAscii__leakignore() {
  char *p = strdup(str);
  result = wxString::IsAscii();
  // cppcheck-suppress memleak
}

void test__wxString__IsWord__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::IsWord();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__IsWord__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::IsWord();
}

void test__wxString__IsWord__leakignore() {
  char *p = strdup(str);
  result = wxString::IsWord();
  // cppcheck-suppress memleak
}

void test__wxString__Len__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::Len();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Len__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::Len();
}

void test__wxString__Len__leakignore() {
  char *p = strdup(str);
  result = wxString::Len();
  // cppcheck-suppress memleak
}

void test__wxString__length__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::length();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__length__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::length();
}

void test__wxString__length__leakignore() {
  char *p = strdup(str);
  result = wxString::length();
  // cppcheck-suppress memleak
}

void test__wxString__Length__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::Length();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Length__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::Length();
}

void test__wxString__Length__leakignore() {
  char *p = strdup(str);
  result = wxString::Length();
  // cppcheck-suppress memleak
}

void test__wxString__Lower__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::Lower();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Lower__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::Lower();
}

void test__wxString__Lower__leakignore() {
  char *p = strdup(str);
  result = wxString::Lower();
  // cppcheck-suppress memleak
}

void test__wxString__MakeCapitalized__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::MakeCapitalized();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__MakeCapitalized__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::MakeCapitalized();
}

void test__wxString__MakeCapitalized__leakignore() {
  char *p = strdup(str);
  result = wxString::MakeCapitalized();
  // cppcheck-suppress memleak
}

void test__wxString__MakeLower__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::MakeLower();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__MakeLower__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::MakeLower();
}

void test__wxString__MakeLower__leakignore() {
  char *p = strdup(str);
  result = wxString::MakeLower();
  // cppcheck-suppress memleak
}

void test__wxString__MakeUpper__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::MakeUpper();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__MakeUpper__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::MakeUpper();
}

void test__wxString__MakeUpper__leakignore() {
  char *p = strdup(str);
  result = wxString::MakeUpper();
  // cppcheck-suppress memleak
}

void test__wxString__Matches__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxString::Matches(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__Matches__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxString::Matches(arg1);
}

void test__wxString__Matches__leakignore() {
  char *p = strdup(str);
  result = wxString::Matches(p);
  // cppcheck-suppress memleak
}

void test__wxString__Matches__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxString::Matches(x);
}

void test__wxString__LowerCase__noreturn() {
  int x = 100;
  if (cond) x=1; else wxString::LowerCase();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxString__LowerCase__leakignore() {
  char *p = strdup(str);
  wxString::LowerCase();
  // cppcheck-suppress memleak
}

void test__wxSysErrorCode__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSysErrorCode();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSysErrorCode__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSysErrorCode();
}

void test__wxLogMessage__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogMessage(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogMessage__leakignore() {
  char *p = strdup(str);
  wxLogMessage(p);
  // cppcheck-suppress memleak
}

void test__wxLogMessage__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogMessage(!x);
}

void test__wxLogMessage__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogMessage(NULL);
}

void test__wxLogMessage__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogMessage(x);
}

void test__wxLogVerbose__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogVerbose(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogVerbose__leakignore() {
  char *p = strdup(str);
  wxLogVerbose(p);
  // cppcheck-suppress memleak
}

void test__wxLogVerbose__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogVerbose(!x);
}

void test__wxLogVerbose__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogVerbose(NULL);
}

void test__wxLogVerbose__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogVerbose(x);
}

void test__wxLogWarning__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogWarning(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogWarning__leakignore() {
  char *p = strdup(str);
  wxLogWarning(p);
  // cppcheck-suppress memleak
}

void test__wxLogWarning__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogWarning(!x);
}

void test__wxLogWarning__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogWarning(NULL);
}

void test__wxLogWarning__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogWarning(x);
}

void test__wxLogFatalError__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogFatalError(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogFatalError__leakignore() {
  char *p = strdup(str);
  wxLogFatalError(p);
  // cppcheck-suppress memleak
}

void test__wxLogFatalError__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogFatalError(!x);
}

void test__wxLogFatalError__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogFatalError(NULL);
}

void test__wxLogFatalError__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogFatalError(x);
}

void test__wxLogError__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogError(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogError__leakignore() {
  char *p = strdup(str);
  wxLogError(p);
  // cppcheck-suppress memleak
}

void test__wxLogError__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogError(!x);
}

void test__wxLogError__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogError(NULL);
}

void test__wxLogError__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogError(x);
}

void test__wxLogTrace__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogTrace(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogTrace__leakignore() {
  char *p = strdup(str);
  wxLogTrace(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxLogTrace__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogTrace(arg1, !x);
}

void test__wxLogTrace__arg2__notnull() {
  // cppcheck-suppress nullPointer
  wxLogTrace(arg1, NULL);
}

void test__wxLogTrace__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogTrace(arg1, x);
}

void test__wxLogDebug__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogDebug(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogDebug__leakignore() {
  char *p = strdup(str);
  wxLogDebug(p);
  // cppcheck-suppress memleak
}

void test__wxLogDebug__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogDebug(!x);
}

void test__wxLogDebug__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogDebug(NULL);
}

void test__wxLogDebug__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogDebug(x);
}

void test__wxLogSysError__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogSysError(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogSysError__leakignore() {
  char *p = strdup(str);
  wxLogSysError(p);
  // cppcheck-suppress memleak
}

void test__wxLogSysError__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogSysError(!x);
}

void test__wxLogSysError__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogSysError(NULL);
}

void test__wxLogSysError__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogSysError(x);
}

void test__wxLogGeneric__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogGeneric(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogGeneric__leakignore() {
  char *p = strdup(str);
  wxLogGeneric(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxLogGeneric__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxLogGeneric(x, arg2);
}

void test__wxLogGeneric__arg2__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogGeneric(arg1, !x);
}

void test__wxLogGeneric__arg2__notnull() {
  // cppcheck-suppress nullPointer
  wxLogGeneric(arg1, NULL);
}

void test__wxLogGeneric__arg2__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogGeneric(arg1, x);
}

void test__wxLogInfo__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLogInfo(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLogInfo__leakignore() {
  char *p = strdup(str);
  wxLogInfo(p);
  // cppcheck-suppress memleak
}

void test__wxLogInfo__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxLogInfo(!x);
}

void test__wxLogInfo__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxLogInfo(NULL);
}

void test__wxLogInfo__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxLogInfo(x);
}

void test__wxSpinCtrl__GetMax__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrl::GetMax();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrl__GetMax__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrl::GetMax();
}

void test__wxSpinCtrl__GetMax__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrl::GetMax();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrl__GetMin__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrl::GetMin();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrl__GetMin__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrl::GetMin();
}

void test__wxSpinCtrl__GetMin__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrl::GetMin();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrl__GetBase__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrl::GetBase();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrl__GetBase__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrl::GetBase();
}

void test__wxSpinCtrl__GetBase__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrl::GetBase();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrl__GetValue__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrl::GetValue();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrl__GetValue__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrl::GetValue();
}

void test__wxSpinCtrl__GetValue__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrl::GetValue();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrl__SetBase__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSpinCtrl::SetBase(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrl__SetBase__pure(int arg1) {
  // cppcheck-suppress incorrectLogicOperator
  if ((wxSpinCtrl::SetBase(arg1) > 10) || (wxSpinCtrl::SetBase(arg1) < 100)) {}
}

void test__wxSpinCtrl__SetBase__leakignore() {
  char *p = strdup(str);
  wxSpinCtrl::SetBase(p);
  // cppcheck-suppress memleak
}

void test__wxSpinCtrl__SetBase__arg1__notbool() {
  // cppcheck-suppress invalidFunctionArgBool
  wxSpinCtrl::SetBase(!x);
}

void test__wxSpinCtrl__SetBase__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrl::SetBase(x);
}

void test__wxSpinCtrlDouble__GetDigits__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrlDouble::GetDigits();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__GetDigits__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrlDouble::GetDigits();
}

void test__wxSpinCtrlDouble__GetDigits__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrlDouble::GetDigits();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__GetIncrement__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrlDouble::GetIncrement();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__GetIncrement__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrlDouble::GetIncrement();
}

void test__wxSpinCtrlDouble__GetIncrement__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrlDouble::GetIncrement();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__GetMax__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrlDouble::GetMax();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__GetMax__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrlDouble::GetMax();
}

void test__wxSpinCtrlDouble__GetMax__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrlDouble::GetMax();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__GetMin__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrlDouble::GetMin();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__GetMin__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrlDouble::GetMin();
}

void test__wxSpinCtrlDouble__GetMin__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrlDouble::GetMin();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__GetValue__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSpinCtrlDouble::GetValue();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__GetValue__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSpinCtrlDouble::GetValue();
}

void test__wxSpinCtrlDouble__GetValue__leakignore() {
  char *p = strdup(str);
  result = wxSpinCtrlDouble::GetValue();
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__SetDigits__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSpinCtrlDouble::SetDigits(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__SetDigits__leakignore() {
  char *p = strdup(str);
  wxSpinCtrlDouble::SetDigits(p);
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__SetDigits__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrlDouble::SetDigits(x);
}

void test__wxSpinCtrlDouble__SetIncrement__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSpinCtrlDouble::SetIncrement(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__SetIncrement__leakignore() {
  char *p = strdup(str);
  wxSpinCtrlDouble::SetIncrement(p);
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__SetIncrement__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrlDouble::SetIncrement(x);
}

void test__wxSpinCtrlDouble__SetRange__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSpinCtrlDouble::SetRange(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__SetRange__leakignore() {
  char *p = strdup(str);
  wxSpinCtrlDouble::SetRange(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__SetRange__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrlDouble::SetRange(x, arg2);
}

void test__wxSpinCtrlDouble__SetRange__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrlDouble::SetRange(arg1, x);
}

void test__wxSpinCtrlDouble__SetValue__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSpinCtrlDouble::SetValue(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSpinCtrlDouble__SetValue__leakignore() {
  char *p = strdup(str);
  wxSpinCtrlDouble::SetValue(p);
  // cppcheck-suppress memleak
}

void test__wxSpinCtrlDouble__SetValue__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSpinCtrlDouble::SetValue(x);
}

void test__wxSlider__GetLineSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetLineSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetLineSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetLineSize();
}

void test__wxSlider__GetLineSize__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetLineSize();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetMax__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetMax();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetMax__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetMax();
}

void test__wxSlider__GetMax__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetMax();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetMin__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetMin();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetMin__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetMin();
}

void test__wxSlider__GetMin__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetMin();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetPageSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetPageSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetPageSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetPageSize();
}

void test__wxSlider__GetPageSize__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetPageSize();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetSelEnd__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetSelEnd();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetSelEnd__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetSelEnd();
}

void test__wxSlider__GetSelEnd__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetSelEnd();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetSelStart__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetSelStart();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetSelStart__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetSelStart();
}

void test__wxSlider__GetSelStart__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetSelStart();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetThumbLength__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetThumbLength();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetThumbLength__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetThumbLength();
}

void test__wxSlider__GetThumbLength__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetThumbLength();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetTickFreq__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetTickFreq();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetTickFreq__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetTickFreq();
}

void test__wxSlider__GetTickFreq__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetTickFreq();
  // cppcheck-suppress memleak
}

void test__wxSlider__GetValue__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxSlider::GetValue();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSlider__GetValue__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxSlider::GetValue();
}

void test__wxSlider__GetValue__leakignore() {
  char *p = strdup(str);
  result = wxSlider::GetValue();
  // cppcheck-suppress memleak
}

void test__wxTimer__GetId__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTimer::GetId();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__GetId__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTimer::GetId();
}

void test__wxTimer__GetId__leakignore() {
  char *p = strdup(str);
  result = wxTimer::GetId();
  // cppcheck-suppress memleak
}

void test__wxTimer__GetInterval__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTimer::GetInterval();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__GetInterval__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTimer::GetInterval();
}

void test__wxTimer__GetInterval__leakignore() {
  char *p = strdup(str);
  result = wxTimer::GetInterval();
  // cppcheck-suppress memleak
}

void test__wxTimer__GetOwner__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTimer::GetOwner();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__GetOwner__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTimer::GetOwner();
}

void test__wxTimer__GetOwner__leakignore() {
  char *p = strdup(str);
  result = wxTimer::GetOwner();
  // cppcheck-suppress memleak
}

void test__wxTimer__IsOneShot__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTimer::IsOneShot();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__IsOneShot__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTimer::IsOneShot();
}

void test__wxTimer__IsOneShot__leakignore() {
  char *p = strdup(str);
  result = wxTimer::IsOneShot();
  // cppcheck-suppress memleak
}

void test__wxTimer__IsRunning__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTimer::IsRunning();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__IsRunning__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTimer::IsRunning();
}

void test__wxTimer__IsRunning__leakignore() {
  char *p = strdup(str);
  result = wxTimer::IsRunning();
  // cppcheck-suppress memleak
}

void test__wxTimer__Notify__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTimer::Notify();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__Notify__leakignore() {
  char *p = strdup(str);
  wxTimer::Notify();
  // cppcheck-suppress memleak
}

void test__wxTimer__SetOwner__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTimer::SetOwner(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__SetOwner__leakignore() {
  char *p = strdup(str);
  wxTimer::SetOwner(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxTimer__SetOwner__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxTimer::SetOwner(NULL, arg2);
}

void test__wxTimer__SetOwner__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxTimer::SetOwner(x, arg2);
}

void test__wxTimer__SetOwner__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTimer::SetOwner(arg1, x);
}

void test__wxTimer__Start__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTimer::Start(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__Start__leakignore() {
  char *p = strdup(str);
  wxTimer::Start(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxTimer__Start__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTimer::Start(x, arg2);
}

void test__wxTimer__Start__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTimer::Start(arg1, x);
}

void test__wxTimer__StartOnce__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTimer::StartOnce(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__StartOnce__leakignore() {
  char *p = strdup(str);
  wxTimer::StartOnce(p);
  // cppcheck-suppress memleak
}

void test__wxTimer__StartOnce__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTimer::StartOnce(x);
}

void test__wxTimer__Stop__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTimer::Stop();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTimer__Stop__leakignore() {
  char *p = strdup(str);
  wxTimer::Stop();
  // cppcheck-suppress memleak
}

void test__wxRadioBox__Enable__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::Enable(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__Enable__leakignore() {
  char *p = strdup(str);
  wxRadioBox::Enable(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__Enable__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::Enable(x, arg2);
}

void test__wxRadioBox__Enable__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::Enable(arg1, x);
}

void test__wxRadioBox__FindString__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::FindString(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__FindString__leakignore() {
  char *p = strdup(str);
  wxRadioBox::FindString(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__FindString__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::FindString(x, arg2);
}

void test__wxRadioBox__FindString__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::FindString(arg1, x);
}

void test__wxRadioBox__GetColumnCount__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetColumnCount();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetColumnCount__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetColumnCount();
}

void test__wxRadioBox__GetColumnCount__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetColumnCount();
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetItemFromPoint__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetItemFromPoint(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetItemFromPoint__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetItemFromPoint(arg1);
}

void test__wxRadioBox__GetItemFromPoint__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetItemFromPoint(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetItemFromPoint__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::GetItemFromPoint(x);
}

void test__wxRadioBox__GetItemHelpText__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetItemHelpText(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetItemHelpText__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetItemHelpText(arg1);
}

void test__wxRadioBox__GetItemHelpText__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetItemHelpText(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetItemHelpText__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::GetItemHelpText(x);
}

void test__wxRadioBox__GetItemToolTip__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetItemToolTip(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetItemToolTip__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetItemToolTip(arg1);
}

void test__wxRadioBox__GetItemToolTip__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetItemToolTip(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetItemToolTip__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::GetItemToolTip(x);
}

void test__wxRadioBox__GetRowCount__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::GetRowCount();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetRowCount__leakignore() {
  char *p = strdup(str);
  wxRadioBox::GetRowCount();
  // cppcheck-suppress memleak
}

void test__wxRadioBox__IsItemEnabled__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::IsItemEnabled(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__IsItemEnabled__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::IsItemEnabled(arg1);
}

void test__wxRadioBox__IsItemEnabled__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::IsItemEnabled(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__IsItemEnabled__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::IsItemEnabled(x);
}

void test__wxRadioBox__IsItemShown__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::IsItemShown(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__IsItemShown__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::IsItemShown(arg1);
}

void test__wxRadioBox__IsItemShown__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::IsItemShown(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__IsItemShown__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::IsItemShown(x);
}

void test__wxRadioBox__SetItemHelpText__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::SetItemHelpText(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__SetItemHelpText__leakignore() {
  char *p = strdup(str);
  wxRadioBox::SetItemHelpText(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__SetItemHelpText__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetItemHelpText(x, arg2);
}

void test__wxRadioBox__SetItemHelpText__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetItemHelpText(arg1, x);
}

void test__wxRadioBox__SetItemToolTip__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::SetItemToolTip(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__SetItemToolTip__leakignore() {
  char *p = strdup(str);
  wxRadioBox::SetItemToolTip(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__SetItemToolTip__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetItemToolTip(x, arg2);
}

void test__wxRadioBox__SetItemToolTip__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetItemToolTip(arg1, x);
}

void test__wxRadioBox__SetSelection__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::SetSelection(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__SetSelection__leakignore() {
  char *p = strdup(str);
  wxRadioBox::SetSelection(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__SetSelection__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetSelection(x);
}

void test__wxRadioBox__Show__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::Show(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__Show__leakignore() {
  char *p = strdup(str);
  wxRadioBox::Show(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__Show__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::Show(x, arg2);
}

void test__wxRadioBox__Show__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::Show(arg1, x);
}

void test__wxRadioBox__GetCount__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetCount();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetCount__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetCount();
}

void test__wxRadioBox__GetCount__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetCount();
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetString__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetString(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetString__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetString(arg1);
}

void test__wxRadioBox__GetString__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetString(p);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__GetString__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxRadioBox::GetString(x);
}

void test__wxRadioBox__SetString__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRadioBox::SetString(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__SetString__leakignore() {
  char *p = strdup(str);
  wxRadioBox::SetString(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRadioBox__SetString__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetString(x, arg2);
}

void test__wxRadioBox__SetString__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRadioBox::SetString(arg1, x);
}

void test__wxRadioBox__GetSelection__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxRadioBox::GetSelection();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRadioBox__GetSelection__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxRadioBox::GetSelection();
}

void test__wxRadioBox__GetSelection__leakignore() {
  char *p = strdup(str);
  result = wxRadioBox::GetSelection();
  // cppcheck-suppress memleak
}

void test__wxButton__GetAuthNeeded__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxButton::GetAuthNeeded();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxButton__GetAuthNeeded__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxButton::GetAuthNeeded();
}

void test__wxButton__GetAuthNeeded__leakignore() {
  char *p = strdup(str);
  result = wxButton::GetAuthNeeded();
  // cppcheck-suppress memleak
}

void test__wxButton__GetLabel__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxButton::GetLabel();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxButton__GetLabel__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxButton::GetLabel();
}

void test__wxButton__GetLabel__leakignore() {
  char *p = strdup(str);
  result = wxButton::GetLabel();
  // cppcheck-suppress memleak
}

void test__wxButton__SetAuthNeeded__noreturn() {
  int x = 100;
  if (cond) x=1; else wxButton::SetAuthNeeded(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxButton__SetAuthNeeded__leakignore() {
  char *p = strdup(str);
  wxButton::SetAuthNeeded(p);
  // cppcheck-suppress memleak
}

void test__wxButton__SetAuthNeeded__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxButton::SetAuthNeeded(x);
}

void test__wxButton__SetDefault__noreturn() {
  int x = 100;
  if (cond) x=1; else wxButton::SetDefault();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxButton__SetDefault__leakignore() {
  char *p = strdup(str);
  wxButton::SetDefault();
  // cppcheck-suppress memleak
}

void test__wxButton__SetLabel__noreturn() {
  int x = 100;
  if (cond) x=1; else wxButton::SetLabel(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxButton__SetLabel__leakignore() {
  char *p = strdup(str);
  wxButton::SetLabel(p);
  // cppcheck-suppress memleak
}

void test__wxButton__SetLabel__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxButton::SetLabel(x);
}

void test__wxColour__Alpha__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxColour::Alpha();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxColour__Alpha__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxColour::Alpha();
}

void test__wxColour__Alpha__leakignore() {
  char *p = strdup(str);
  result = wxColour::Alpha();
  // cppcheck-suppress memleak
}

void test__wxColour__Blue__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxColour::Blue();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxColour__Blue__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxColour::Blue();
}

void test__wxColour__Blue__leakignore() {
  char *p = strdup(str);
  result = wxColour::Blue();
  // cppcheck-suppress memleak
}

void test__wxColour__Green__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxColour::Green();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxColour__Green__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxColour::Green();
}

void test__wxColour__Green__leakignore() {
  char *p = strdup(str);
  result = wxColour::Green();
  // cppcheck-suppress memleak
}

void test__wxColour__Red__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxColour::Red();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxColour__Red__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxColour::Red();
}

void test__wxColour__Red__leakignore() {
  char *p = strdup(str);
  result = wxColour::Red();
  // cppcheck-suppress memleak
}

void test__wxTextFile__AddLine__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::AddLine(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__AddLine__leakignore() {
  char *p = strdup(str);
  wxTextFile::AddLine(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxTextFile__AddLine__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::AddLine(x, arg2);
}

void test__wxTextFile__AddLine__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::AddLine(arg1, x);
}

void test__wxTextFile__Clear__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::Clear();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__Clear__leakignore() {
  char *p = strdup(str);
  wxTextFile::Clear();
  // cppcheck-suppress memleak
}

void test__wxTextFile__Close__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::Close();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__Close__leakignore() {
  char *p = strdup(str);
  wxTextFile::Close();
  // cppcheck-suppress memleak
}

void test__wxTextFile__Create__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::Create(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__Create__leakignore() {
  char *p = strdup(str);
  wxTextFile::Create(p);
  // cppcheck-suppress memleak
}

void test__wxTextFile__Create__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::Create(x);
}

void test__wxTextFile__Eof__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::Eof();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__Eof__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::Eof();
}

void test__wxTextFile__Eof__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::Eof();
  // cppcheck-suppress memleak
}

void test__wxTextFile__Exists__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::Exists();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__Exists__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::Exists();
}

void test__wxTextFile__Exists__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::Exists();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetCurrentLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetCurrentLine();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetCurrentLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetCurrentLine();
}

void test__wxTextFile__GetCurrentLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetCurrentLine();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetFirstLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetFirstLine();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetFirstLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetFirstLine();
}

void test__wxTextFile__GetFirstLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetFirstLine();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetLastLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetLastLine();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetLastLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetLastLine();
}

void test__wxTextFile__GetLastLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetLastLine();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetLineCount__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetLineCount();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetLineCount__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetLineCount();
}

void test__wxTextFile__GetLineCount__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetLineCount();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetLineType__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetLineType();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetLineType__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetLineType();
}

void test__wxTextFile__GetLineType__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetLineType();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetName__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetName();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetName__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetName();
}

void test__wxTextFile__GetName__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetName();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetNextLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetNextLine();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetNextLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetNextLine();
}

void test__wxTextFile__GetNextLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetNextLine();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetPrevLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetPrevLine();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetPrevLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetPrevLine();
}

void test__wxTextFile__GetPrevLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetPrevLine();
  // cppcheck-suppress memleak
}

void test__wxTextFile__GoToLine__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::GoToLine(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GoToLine__leakignore() {
  char *p = strdup(str);
  wxTextFile::GoToLine(p);
  // cppcheck-suppress memleak
}

void test__wxTextFile__GoToLine__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::GoToLine(x);
}

void test__wxTextFile__GuessType__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GuessType();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GuessType__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GuessType();
}

void test__wxTextFile__GuessType__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GuessType();
  // cppcheck-suppress memleak
}

void test__wxTextFile__InsertLine__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::InsertLine(arg1, arg2, arg3);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__InsertLine__leakignore() {
  char *p = strdup(str);
  wxTextFile::InsertLine(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__wxTextFile__InsertLine__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::InsertLine(x, arg2, arg3);
}

void test__wxTextFile__InsertLine__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::InsertLine(arg1, x, arg3);
}

void test__wxTextFile__InsertLine__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::InsertLine(arg1, arg2, x);
}

void test__wxTextFile__IsOpened__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::IsOpened();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__IsOpened__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::IsOpened();
}

void test__wxTextFile__IsOpened__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::IsOpened();
  // cppcheck-suppress memleak
}

void test__wxTextFile__RemoveLine__noreturn() {
  int x = 100;
  if (cond) x=1; else wxTextFile::RemoveLine(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__RemoveLine__leakignore() {
  char *p = strdup(str);
  wxTextFile::RemoveLine(p);
  // cppcheck-suppress memleak
}

void test__wxTextFile__RemoveLine__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxTextFile::RemoveLine(x);
}

void test__wxTextFile__GetLine__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxTextFile::GetLine(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxTextFile__GetLine__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxTextFile::GetLine(arg1);
}

void test__wxTextFile__GetLine__leakignore() {
  char *p = strdup(str);
  result = wxTextFile::GetLine(p);
  // cppcheck-suppress memleak
}

void test__wxTextFile__GetLine__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxTextFile::GetLine(x);
}

void test__wxSizer__AddSpacer__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSizer::AddSpacer(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSizer__AddSpacer__leakignore() {
  char *p = strdup(str);
  wxSizer::AddSpacer(p);
  // cppcheck-suppress memleak
}

void test__wxSizer__AddSpacer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSizer::AddSpacer(x);
}

void test__wxBoxSizer__AddSpacer__noreturn() {
  int x = 100;
  if (cond) x=1; else wxBoxSizer::AddSpacer(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxBoxSizer__AddSpacer__leakignore() {
  char *p = strdup(str);
  wxBoxSizer::AddSpacer(p);
  // cppcheck-suppress memleak
}

void test__wxBoxSizer__AddSpacer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxBoxSizer::AddSpacer(x);
}

void test__wxBoxSizer__CalcMin__noreturn() {
  int x = 100;
  if (cond) x=1; else wxBoxSizer::CalcMin();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxBoxSizer__CalcMin__leakignore() {
  char *p = strdup(str);
  wxBoxSizer::CalcMin();
  // cppcheck-suppress memleak
}

void test__wxBoxSizer__GetOrientation__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxBoxSizer::GetOrientation();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxBoxSizer__GetOrientation__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxBoxSizer::GetOrientation();
}

void test__wxBoxSizer__GetOrientation__leakignore() {
  char *p = strdup(str);
  result = wxBoxSizer::GetOrientation();
  // cppcheck-suppress memleak
}

void test__wxBoxSizer__RecalcSizes__noreturn() {
  int x = 100;
  if (cond) x=1; else wxBoxSizer::RecalcSizes();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxBoxSizer__RecalcSizes__leakignore() {
  char *p = strdup(str);
  wxBoxSizer::RecalcSizes();
  // cppcheck-suppress memleak
}

void test__wxBoxSizer__SetOrientation__noreturn() {
  int x = 100;
  if (cond) x=1; else wxBoxSizer::SetOrientation(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxBoxSizer__SetOrientation__leakignore() {
  char *p = strdup(str);
  wxBoxSizer::SetOrientation(p);
  // cppcheck-suppress memleak
}

void test__wxBoxSizer__SetOrientation__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxBoxSizer::SetOrientation(x);
}

void test__wxStaticBoxSizer__CalcMin__noreturn() {
  int x = 100;
  if (cond) x=1; else wxStaticBoxSizer::CalcMin();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxStaticBoxSizer__CalcMin__leakignore() {
  char *p = strdup(str);
  wxStaticBoxSizer::CalcMin();
  // cppcheck-suppress memleak
}

void test__wxStaticBoxSizer__GetStaticBox__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxStaticBoxSizer::GetStaticBox();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxStaticBoxSizer__GetStaticBox__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxStaticBoxSizer::GetStaticBox();
}

void test__wxStaticBoxSizer__GetStaticBox__leakignore() {
  char *p = strdup(str);
  result = wxStaticBoxSizer::GetStaticBox();
  // cppcheck-suppress memleak
}

void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
  int x = 100;
  if (cond) x=1; else wxStaticBoxSizer::RecalcSizes();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxStaticBoxSizer__RecalcSizes__leakignore() {
  char *p = strdup(str);
  wxStaticBoxSizer::RecalcSizes();
  // cppcheck-suppress memleak
}

void test__wxMenu__Append__noreturn() {
  int x = 100;
  if (cond) x=1; else wxMenu::Append(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxMenu__Append__leakignore() {
  char *p = strdup(str);
  wxMenu::Append(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__wxMenu__Append__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxMenu::Append(x, arg2, arg3, arg4);
}

void test__wxMenu__Append__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxMenu::Append(arg1, arg2, arg3, x);
}

void test__wxLaunchDefaultBrowser__noreturn() {
  int x = 100;
  if (cond) x=1; else wxLaunchDefaultBrowser(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxLaunchDefaultBrowser__leakignore() {
  char *p = strdup(str);
  wxLaunchDefaultBrowser(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxLaunchDefaultBrowser__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxLaunchDefaultBrowser(x, arg2);
}

void test__wxLaunchDefaultBrowser__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxLaunchDefaultBrowser(arg1, x);
}

void test__wxDirExists__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxDirExists(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDirExists__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxDirExists(arg1);
}

void test__wxDirExists__leakignore() {
  char *p = strdup(str);
  result = wxDirExists(p);
  // cppcheck-suppress memleak
}

void test__wxDirExists__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxDirExists(x);
}

void test__wxFileExists__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxFileExists(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxFileExists__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxFileExists(arg1);
}

void test__wxFileExists__leakignore() {
  char *p = strdup(str);
  result = wxFileExists(p);
  // cppcheck-suppress memleak
}

void test__wxFileExists__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxFileExists(x);
}

void test__wxGetWorkingDirectory__noreturn() {
  int x = 100;
  if (cond) x=1; else wxGetWorkingDirectory(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxGetWorkingDirectory__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGetWorkingDirectory(arg1, x);
}

void test__wxGetCwd__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxGetCwd();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxGetCwd__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxGetCwd();
}

void test__wxSetWorkingDirectory__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSetWorkingDirectory(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSetWorkingDirectory__leakignore() {
  char *p = strdup(str);
  wxSetWorkingDirectory(p);
  // cppcheck-suppress memleak
}

void test__wxSetWorkingDirectory__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSetWorkingDirectory(x);
}

void test__wxMkdir__noreturn() {
  int x = 100;
  if (cond) x=1; else wxMkdir(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxMkdir__leakignore() {
  char *p = strdup(str);
  wxMkdir(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxMkdir__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxMkdir(x, arg2);
}

void test__wxMkdir__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxMkdir(arg1, x);
}

void test__wxRmdir__noreturn() {
  int x = 100;
  if (cond) x=1; else wxRmdir(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxRmdir__leakignore() {
  char *p = strdup(str);
  wxRmdir(p, arg2);
  // cppcheck-suppress memleak
}

void test__wxRmdir__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRmdir(x, arg2);
}

void test__wxRmdir__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxRmdir(arg1, x);
}

void test__wxGetTranslation__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxGetTranslation(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxGetTranslation__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxGetTranslation(arg1, arg2, arg3, arg4);
}

void test__wxGetTranslation__leakignore() {
  char *p = strdup(str);
  result = wxGetTranslation(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__wxGetTranslation__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxGetTranslation(x, arg2, arg3, arg4);
}

void test__wxGetTranslation__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxGetTranslation(arg1, x, arg3, arg4);
}

void test__wxGetTranslation__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxGetTranslation(arg1, arg2, x, arg4);
}

void test__wxGetTranslation__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxGetTranslation(arg1, arg2, arg3, x);
}

void test__wxApp__MacOpenFile__noreturn() {
  int x = 100;
  if (cond) x=1; else wxApp::MacOpenFile(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxApp__MacOpenFile__leakignore() {
  char *p = strdup(str);
  wxApp::MacOpenFile(p);
  // cppcheck-suppress memleak
}

void test__wxApp__MacOpenFile__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxApp::MacOpenFile(x);
}

void test__wxArtProvider__Insert__noreturn() {
  int x = 100;
  if (cond) x=1; else wxArtProvider::Insert(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxArtProvider__Insert__leakignore() {
  char *p = strdup(str);
  wxArtProvider::Insert(p);
  // cppcheck-suppress memleak
}

void test__wxArtProvider__Insert__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxArtProvider::Insert(NULL);
}

void test__wxArtProvider__Insert__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxArtProvider::Insert(x);
}

void test__wxCalendarCtrl__EnableYearChange__noreturn() {
  int x = 100;
  if (cond) x=1; else wxCalendarCtrl::EnableYearChange(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxCalendarCtrl__EnableYearChange__leakignore() {
  char *p = strdup(str);
  wxCalendarCtrl::EnableYearChange(p);
  // cppcheck-suppress memleak
}

void test__wxCalendarCtrl__EnableYearChange__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxCalendarCtrl::EnableYearChange(x);
}

void test__wxComboCtrl__GetTextIndent__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxComboCtrl::GetTextIndent();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxComboCtrl__GetTextIndent__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxComboCtrl::GetTextIndent();
}

void test__wxComboCtrl__GetTextIndent__leakignore() {
  char *p = strdup(str);
  result = wxComboCtrl::GetTextIndent();
  // cppcheck-suppress memleak
}

void test__wxComboCtrl__HidePopup__noreturn() {
  int x = 100;
  if (cond) x=1; else wxComboCtrl::HidePopup(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxComboCtrl__HidePopup__leakignore() {
  char *p = strdup(str);
  wxComboCtrl::HidePopup(p);
  // cppcheck-suppress memleak
}

void test__wxComboCtrl__HidePopup__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxComboCtrl::HidePopup(x);
}

void test__wxComboCtrl__ShowPopup__noreturn() {
  int x = 100;
  if (cond) x=1; else wxComboCtrl::ShowPopup();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxComboCtrl__ShowPopup__leakignore() {
  char *p = strdup(str);
  wxComboCtrl::ShowPopup();
  // cppcheck-suppress memleak
}

void test__wxComboCtrl__SetTextIndent__noreturn() {
  int x = 100;
  if (cond) x=1; else wxComboCtrl::SetTextIndent(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxComboCtrl__SetTextIndent__leakignore() {
  char *p = strdup(str);
  wxComboCtrl::SetTextIndent(p);
  // cppcheck-suppress memleak
}

void test__wxComboCtrl__SetTextIndent__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxComboCtrl::SetTextIndent(x);
}

void test__wxDataViewCustomRenderer__Activate__noreturn() {
  int x = 100;
  if (cond) x=1; else wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDataViewCustomRenderer__Activate__leakignore() {
  char *p = strdup(str);
  wxDataViewCustomRenderer::Activate(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__wxDataViewCustomRenderer__Activate__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::Activate(x, arg2, arg3, arg4);
}

void test__wxDataViewCustomRenderer__Activate__arg2__notnull() {
  // cppcheck-suppress nullPointer
  wxDataViewCustomRenderer::Activate(arg1, NULL, arg3, arg4);
}

void test__wxDataViewCustomRenderer__Activate__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::Activate(arg1, arg2, x, arg4);
}

void test__wxDataViewCustomRenderer__Activate__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::Activate(arg1, arg2, arg3, x);
}

void test__wxDataViewCustomRenderer__LeftClick__noreturn() {
  int x = 100;
  if (cond) x=1; else wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, arg5);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDataViewCustomRenderer__LeftClick__leakignore() {
  char *p = strdup(str);
  wxDataViewCustomRenderer::LeftClick(p, arg2, arg3, arg4, arg5);
  // cppcheck-suppress memleak
}

void test__wxDataViewCustomRenderer__LeftClick__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::LeftClick(x, arg2, arg3, arg4, arg5);
}

void test__wxDataViewCustomRenderer__LeftClick__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::LeftClick(arg1, x, arg3, arg4, arg5);
}

void test__wxDataViewCustomRenderer__LeftClick__arg3__notnull() {
  // cppcheck-suppress nullPointer
  wxDataViewCustomRenderer::LeftClick(arg1, arg2, NULL, arg4, arg5);
}

void test__wxDataViewCustomRenderer__LeftClick__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, x, arg5);
}

void test__wxDataViewCustomRenderer__LeftClick__arg5__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDataViewCustomRenderer::LeftClick(arg1, arg2, arg3, arg4, x);
}

void test__wxDebugContext__GetLevel__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxDebugContext::GetLevel();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDebugContext__GetLevel__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxDebugContext::GetLevel();
}

void test__wxDebugContext__GetLevel__leakignore() {
  char *p = strdup(str);
  result = wxDebugContext::GetLevel();
  // cppcheck-suppress memleak
}

void test__wxDebugContext__SetLevel__noreturn() {
  int x = 100;
  if (cond) x=1; else wxDebugContext::SetLevel(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDebugContext__SetLevel__leakignore() {
  char *p = strdup(str);
  wxDebugContext::SetLevel(p);
  // cppcheck-suppress memleak
}

void test__wxDebugContext__SetLevel__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxDebugContext::SetLevel(x);
}

void test__wxDos2UnixFilename__noreturn() {
  int x = 100;
  if (cond) x=1; else wxDos2UnixFilename(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxDos2UnixFilename__leakignore() {
  char *p = strdup(str);
  wxDos2UnixFilename(p);
  // cppcheck-suppress memleak
}

void test__wxDos2UnixFilename__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxDos2UnixFilename(NULL);
}

void test__wxDos2UnixFilename__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxDos2UnixFilename(x);
}

void test__wxFileNameFromPath__noreturn() {
  int x = 100;
  if (cond) x=1; else result = wxFileNameFromPath(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxFileNameFromPath__useretval() {
  // cppcheck-suppress ignoredReturnValue
  wxFileNameFromPath(arg1);
}

void test__wxFileNameFromPath__leakignore() {
  char *p = strdup(str);
  result = wxFileNameFromPath(p);
  // cppcheck-suppress memleak
}

void test__wxFileNameFromPath__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = wxFileNameFromPath(x);
}

void test__wxSizerItem__SetWindow__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSizerItem::SetWindow(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSizerItem__SetWindow__leakignore() {
  char *p = strdup(str);
  wxSizerItem::SetWindow(p);
  // cppcheck-suppress memleak
}

void test__wxSizerItem__SetWindow__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxSizerItem::SetWindow(NULL);
}

void test__wxSizerItem__SetWindow__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxSizerItem::SetWindow(x);
}

void test__wxSizerItem__SetSizer__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSizerItem::SetSizer(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSizerItem__SetSizer__leakignore() {
  char *p = strdup(str);
  wxSizerItem::SetSizer(p);
  // cppcheck-suppress memleak
}

void test__wxSizerItem__SetSizer__arg1__notnull() {
  // cppcheck-suppress nullPointer
  wxSizerItem::SetSizer(NULL);
}

void test__wxSizerItem__SetSizer__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  wxSizerItem::SetSizer(x);
}

void test__wxSizerItem__SetSpacer__noreturn() {
  int x = 100;
  if (cond) x=1; else wxSizerItem::SetSpacer(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxSizerItem__SetSpacer__leakignore() {
  char *p = strdup(str);
  wxSizerItem::SetSpacer(p);
  // cppcheck-suppress memleak
}

void test__wxSizerItem__SetSpacer__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxSizerItem::SetSpacer(x);
}

void test__wxGrid__SetCellAlignment__noreturn() {
  int x = 100;
  if (cond) x=1; else wxGrid::SetCellAlignment(arg1, arg2, arg3);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxGrid__SetCellAlignment__leakignore() {
  char *p = strdup(str);
  wxGrid::SetCellAlignment(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__wxGrid__SetCellAlignment__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellAlignment(x, arg2, arg3);
}

void test__wxGrid__SetCellAlignment__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellAlignment(arg1, x, arg3);
}

void test__wxGrid__SetCellAlignment__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellAlignment(arg1, arg2, x);
}

void test__wxGrid__SetCellTextColour__noreturn() {
  int x = 100;
  if (cond) x=1; else wxGrid::SetCellTextColour(arg1, arg2, arg3);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__wxGrid__SetCellTextColour__leakignore() {
  char *p = strdup(str);
  wxGrid::SetCellTextColour(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__wxGrid__SetCellTextColour__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellTextColour(x, arg2, arg3);
}

void test__wxGrid__SetCellTextColour__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellTextColour(arg1, x, arg3);
}

void test__wxGrid__SetCellTextColour__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  wxGrid::SetCellTextColour(arg1, arg2, x);
}