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

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

void test__sf__err__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::err();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__err__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::err();
}

void test__sf__err__leakignore() {
  char *p = strdup(str);
  result = sf::err();
  // cppcheck-suppress memleak
}

void test__sf__sleep__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::sleep(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__sleep__leakignore() {
  char *p = strdup(str);
  sf::sleep(p);
  // cppcheck-suppress memleak
}

void test__sf__sleep__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::sleep(x);
}

void test__sf__Time__asSeconds__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Time::asSeconds();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Time__asSeconds__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Time::asSeconds();
}

void test__sf__Time__asSeconds__leakignore() {
  char *p = strdup(str);
  result = sf::Time::asSeconds();
  // cppcheck-suppress memleak
}

void test__sf__Time__asMilliseconds__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Time::asMilliseconds();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Time__asMilliseconds__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Time::asMilliseconds();
}

void test__sf__Time__asMilliseconds__leakignore() {
  char *p = strdup(str);
  result = sf::Time::asMilliseconds();
  // cppcheck-suppress memleak
}

void test__sf__Time__asMicroseconds__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Time::asMicroseconds();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Time__asMicroseconds__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Time::asMicroseconds();
}

void test__sf__Time__asMicroseconds__leakignore() {
  char *p = strdup(str);
  result = sf::Time::asMicroseconds();
  // cppcheck-suppress memleak
}

void test__sf__String__clear__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::String::clear();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__clear__leakignore() {
  char *p = strdup(str);
  sf::String::clear();
  // cppcheck-suppress memleak
}

void test__sf__String__isEmpty__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::String::isEmpty();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__isEmpty__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::String::isEmpty();
}

void test__sf__String__isEmpty__leakignore() {
  char *p = strdup(str);
  result = sf::String::isEmpty();
  // cppcheck-suppress memleak
}

void test__sf__String__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::String::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::String::getSize();
}

void test__sf__String__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::String::getSize();
  // cppcheck-suppress memleak
}

void test__sf__String__find__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::String::find(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__find__leakignore() {
  char *p = strdup(str);
  sf::String::find(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__String__find__arg1__notnull() {
  // cppcheck-suppress nullPointer
  sf::String::find(NULL, arg2);
}

void test__sf__String__find__arg1__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  sf::String::find(x, arg2);
}

void test__sf__String__find__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::String::find(arg1, x);
}

void test__sf__String__substring__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::String::substring(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__substring__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::String::substring(arg1, arg2);
}

void test__sf__String__substring__leakignore() {
  char *p = strdup(str);
  result = sf::String::substring(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__String__substring__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::String::substring(x, arg2);
}

void test__sf__String__substring__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::String::substring(arg1, x);
}

void test__sf__String__erase__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::String::erase(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__String__erase__leakignore() {
  char *p = strdup(str);
  sf::String::erase(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__String__erase__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::String::erase(x, arg2);
}

void test__sf__String__erase__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::String::erase(arg1, x);
}

void test__sf__RenderTarget__clear__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::clear(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__clear__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::clear(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__clear__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::clear(x);
}

void test__sf__RenderWindow__clear__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::clear(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__clear__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::clear(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__clear__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::clear(x);
}

void test__sf__RenderTexture__clear__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::clear(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__clear__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::clear(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__clear__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::clear(x);
}

void test__sf__RenderTarget__setView__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::setView(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__setView__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::setView(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__setView__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::setView(x);
}

void test__sf__RenderWindow__setView__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setView(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setView__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setView(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setView__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setView(x);
}

void test__sf__RenderTexture__setView__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::setView(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__setView__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::setView(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__setView__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::setView(x);
}

void test__sf__RenderTarget__getView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::getView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__getView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::getView();
}

void test__sf__RenderTarget__getView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::getView();
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__getDefaultView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::getDefaultView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__getDefaultView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::getDefaultView();
}

void test__sf__RenderTarget__getDefaultView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::getDefaultView();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getView();
}

void test__sf__RenderWindow__getView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getView();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getDefaultView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getDefaultView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getDefaultView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getDefaultView();
}

void test__sf__RenderWindow__getDefaultView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getDefaultView();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__getView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::getView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__getView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::getView();
}

void test__sf__RenderTexture__getView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::getView();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__getDefaultView__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::getDefaultView();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__getDefaultView__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::getDefaultView();
}

void test__sf__RenderTexture__getDefaultView__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::getDefaultView();
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__getViewport__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::getViewport(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__getViewport__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::getViewport(arg1);
}

void test__sf__RenderTarget__getViewport__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::getViewport(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__getViewport__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTarget::getViewport(x);
}

void test__sf__RenderWindow__getViewport__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getViewport(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getViewport__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getViewport(arg1);
}

void test__sf__RenderWindow__getViewport__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getViewport(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getViewport__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderWindow::getViewport(x);
}

void test__sf__RenderTexture__getViewport__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::getViewport(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__getViewport__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::getViewport(arg1);
}

void test__sf__RenderTexture__getViewport__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::getViewport(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__getViewport__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTexture::getViewport(x);
}

void test__sf__RenderTarget__mapPixelToCoords__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::mapPixelToCoords(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__mapPixelToCoords__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::mapPixelToCoords(arg1, arg2);
}

void test__sf__RenderTarget__mapPixelToCoords__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::mapPixelToCoords(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__mapPixelToCoords__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTarget::mapPixelToCoords(x, arg2);
}

void test__sf__RenderTarget__mapPixelToCoords__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTarget::mapPixelToCoords(arg1, x);
}

void test__sf__RenderTarget__mapCoordsToPixel__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::mapCoordsToPixel(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__mapCoordsToPixel__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::mapCoordsToPixel(arg1, arg2);
}

void test__sf__RenderTarget__mapCoordsToPixel__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::mapCoordsToPixel(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__mapCoordsToPixel__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTarget::mapCoordsToPixel(x, arg2);
}

void test__sf__RenderTarget__mapCoordsToPixel__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTarget::mapCoordsToPixel(arg1, x);
}

void test__sf__RenderWindow__mapPixelToCoords__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::mapPixelToCoords(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__mapPixelToCoords__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::mapPixelToCoords(arg1, arg2);
}

void test__sf__RenderWindow__mapPixelToCoords__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::mapPixelToCoords(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__mapPixelToCoords__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderWindow::mapPixelToCoords(x, arg2);
}

void test__sf__RenderWindow__mapPixelToCoords__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderWindow::mapPixelToCoords(arg1, x);
}

void test__sf__RenderWindow__mapCoordsToPixel__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__mapCoordsToPixel__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::mapCoordsToPixel(arg1, arg2);
}

void test__sf__RenderWindow__mapCoordsToPixel__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::mapCoordsToPixel(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__mapCoordsToPixel__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderWindow::mapCoordsToPixel(x, arg2);
}

void test__sf__RenderWindow__mapCoordsToPixel__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderWindow::mapCoordsToPixel(arg1, x);
}

void test__sf__RenderTexture__mapPixelToCoords__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::mapPixelToCoords(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__mapPixelToCoords__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::mapPixelToCoords(arg1, arg2);
}

void test__sf__RenderTexture__mapPixelToCoords__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::mapPixelToCoords(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__mapPixelToCoords__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTexture::mapPixelToCoords(x, arg2);
}

void test__sf__RenderTexture__mapPixelToCoords__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTexture::mapPixelToCoords(arg1, x);
}

void test__sf__RenderTexture__mapCoordsToPixel__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__mapCoordsToPixel__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::mapCoordsToPixel(arg1, arg2);
}

void test__sf__RenderTexture__mapCoordsToPixel__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::mapCoordsToPixel(p, arg2);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__mapCoordsToPixel__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTexture::mapCoordsToPixel(x, arg2);
}

void test__sf__RenderTexture__mapCoordsToPixel__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  result = sf::RenderTexture::mapCoordsToPixel(arg1, x);
}

void test__sf__RenderTarget__draw__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::draw(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__draw__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::draw(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__draw__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::draw(x, arg2, arg3, arg4);
}

void test__sf__RenderTarget__draw__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::draw(arg1, x, arg3, arg4);
}

void test__sf__RenderTarget__draw__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::draw(arg1, arg2, x, arg4);
}

void test__sf__RenderTarget__draw__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::draw(arg1, arg2, arg3, x);
}

void test__sf__RenderWindow__draw__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::draw(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__draw__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::draw(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__draw__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::draw(x, arg2, arg3, arg4);
}

void test__sf__RenderWindow__draw__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::draw(arg1, x, arg3, arg4);
}

void test__sf__RenderWindow__draw__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::draw(arg1, arg2, x, arg4);
}

void test__sf__RenderWindow__draw__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::draw(arg1, arg2, arg3, x);
}

void test__sf__RenderTexture__draw__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::draw(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__draw__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::draw(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__draw__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::draw(x, arg2, arg3, arg4);
}

void test__sf__RenderTexture__draw__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::draw(arg1, x, arg3, arg4);
}

void test__sf__RenderTexture__draw__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::draw(arg1, arg2, x, arg4);
}

void test__sf__RenderTexture__draw__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::draw(arg1, arg2, arg3, x);
}

void test__sf__RenderTarget__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTarget::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTarget::getSize();
}

void test__sf__RenderTarget__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTarget::getSize();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getSize();
}

void test__sf__RenderWindow__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getSize();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderTexture::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderTexture::getSize();
}

void test__sf__RenderTexture__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::RenderTexture::getSize();
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__setActive__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::setActive(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__setActive__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::setActive(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__setActive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTarget::setActive(x);
}

void test__sf__RenderWindow__setActive__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setActive(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setActive__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setActive(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setActive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setActive(x);
}

void test__sf__RenderTexture__setActive__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::setActive(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__setActive__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::setActive(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__setActive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderTexture::setActive(x);
}

void test__sf__Window__setActive__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setActive(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setActive__leakignore() {
  char *p = strdup(str);
  sf::Window::setActive(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setActive__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setActive(x);
}

void test__sf__RenderTarget__pushGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::pushGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__pushGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::pushGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__popGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::popGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__popGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::popGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderTarget__resetGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTarget::resetGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTarget__resetGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTarget::resetGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__pushGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::pushGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__pushGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::pushGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__popGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::popGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__popGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::popGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__resetGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::resetGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__resetGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::resetGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__pushGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::pushGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__pushGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::pushGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__popGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::popGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__popGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::popGLStates();
  // cppcheck-suppress memleak
}

void test__sf__RenderTexture__resetGLStates__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderTexture::resetGLStates();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderTexture__resetGLStates__leakignore() {
  char *p = strdup(str);
  sf::RenderTexture::resetGLStates();
  // cppcheck-suppress memleak
}

void test__sf__Window__create__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::create(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__create__leakignore() {
  char *p = strdup(str);
  sf::Window::create(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__sf__Window__create__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::create(x, arg2, arg3, arg4);
}

void test__sf__Window__create__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::create(arg1, x, arg3, arg4);
}

void test__sf__Window__create__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::create(arg1, arg2, x, arg4);
}

void test__sf__Window__create__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::create(arg1, arg2, arg3, x);
}

void test__sf__RenderWindow__create__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::create(arg1, arg2, arg3, arg4);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__create__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::create(p, arg2, arg3, arg4);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__create__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::create(x, arg2, arg3, arg4);
}

void test__sf__RenderWindow__create__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::create(arg1, x, arg3, arg4);
}

void test__sf__RenderWindow__create__arg3__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::create(arg1, arg2, x, arg4);
}

void test__sf__RenderWindow__create__arg4__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::create(arg1, arg2, arg3, x);
}

void test__sf__Window__close__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::close();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__close__leakignore() {
  char *p = strdup(str);
  sf::Window::close();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__close__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::close();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__close__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::close();
  // cppcheck-suppress memleak
}

void test__sf__Window__isOpen__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::isOpen();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__isOpen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::isOpen();
}

void test__sf__Window__isOpen__leakignore() {
  char *p = strdup(str);
  result = sf::Window::isOpen();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__isOpen__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::isOpen();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__isOpen__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::isOpen();
}

void test__sf__RenderWindow__isOpen__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::isOpen();
  // cppcheck-suppress memleak
}

void test__sf__Window__getSettings__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::getSettings();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__getSettings__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::getSettings();
}

void test__sf__Window__getSettings__leakignore() {
  char *p = strdup(str);
  result = sf::Window::getSettings();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getSettings__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getSettings();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getSettings__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getSettings();
}

void test__sf__RenderWindow__getSettings__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getSettings();
  // cppcheck-suppress memleak
}

void test__sf__Window__pollEvent__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::pollEvent(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__pollEvent__leakignore() {
  char *p = strdup(str);
  sf::Window::pollEvent(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__waitEvent__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::waitEvent(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__waitEvent__leakignore() {
  char *p = strdup(str);
  sf::Window::waitEvent(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__pollEvent__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::pollEvent(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__pollEvent__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::pollEvent(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__waitEvent__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::waitEvent(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__waitEvent__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::waitEvent(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__getPosition__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::getPosition();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__getPosition__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::getPosition();
}

void test__sf__Window__getPosition__leakignore() {
  char *p = strdup(str);
  result = sf::Window::getPosition();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getPosition__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getPosition();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getPosition__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getPosition();
}

void test__sf__RenderWindow__getPosition__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getPosition();
  // cppcheck-suppress memleak
}

void test__sf__Window__setPosition__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setPosition(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setPosition__leakignore() {
  char *p = strdup(str);
  sf::Window::setPosition(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setPosition__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setPosition(x);
}

void test__sf__RenderWindow__setPosition__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setPosition(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setPosition__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setPosition(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setPosition__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setPosition(x);
}

void test__sf__Window__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::getSize();
}

void test__sf__Window__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::Window::getSize();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getSize__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getSize();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getSize__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getSize();
}

void test__sf__RenderWindow__getSize__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getSize();
  // cppcheck-suppress memleak
}

void test__sf__Window__setSize__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setSize(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setSize__leakignore() {
  char *p = strdup(str);
  sf::Window::setSize(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setSize__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setSize(x);
}

void test__sf__RenderWindow__setSize__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setSize(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setSize__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setSize(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setSize__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setSize(x);
}

void test__sf__Window__setTitle__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setTitle(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setTitle__leakignore() {
  char *p = strdup(str);
  sf::Window::setTitle(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setTitle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setTitle(x);
}

void test__sf__RenderWindow__setTitle__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setTitle(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setTitle__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setTitle(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setTitle__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setTitle(x);
}

void test__sf__Window__setIcon__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setIcon(arg1, arg2, arg3);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setIcon__leakignore() {
  char *p = strdup(str);
  sf::Window::setIcon(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__sf__Window__setIcon__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setIcon(x, arg2, arg3);
}

void test__sf__Window__setIcon__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setIcon(arg1, x, arg3);
}

void test__sf__Window__setIcon__arg3__notnull() {
  // cppcheck-suppress nullPointer
  sf::Window::setIcon(arg1, arg2, NULL);
}

void test__sf__Window__setIcon__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  sf::Window::setIcon(arg1, arg2, x);
}

void test__sf__RenderWindow__setIcon__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setIcon(arg1, arg2, arg3);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setIcon__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setIcon(p, arg2, arg3);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setIcon__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setIcon(x, arg2, arg3);
}

void test__sf__RenderWindow__setIcon__arg2__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setIcon(arg1, x, arg3);
}

void test__sf__RenderWindow__setIcon__arg3__notnull() {
  // cppcheck-suppress nullPointer
  sf::RenderWindow::setIcon(arg1, arg2, NULL);
}

void test__sf__RenderWindow__setIcon__arg3__notuninit() {
  int x[10];
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setIcon(arg1, arg2, x);
}

void test__sf__Window__setVisible__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setVisible(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setVisible__leakignore() {
  char *p = strdup(str);
  sf::Window::setVisible(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setVisible__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setVisible(x);
}

void test__sf__Window__setVerticalSyncEnabled__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setVerticalSyncEnabled(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setVerticalSyncEnabled__leakignore() {
  char *p = strdup(str);
  sf::Window::setVerticalSyncEnabled(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setVerticalSyncEnabled__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setVerticalSyncEnabled(x);
}

void test__sf__Window__setMouseCursorVisible__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setMouseCursorVisible(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setMouseCursorVisible__leakignore() {
  char *p = strdup(str);
  sf::Window::setMouseCursorVisible(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setMouseCursorVisible__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setMouseCursorVisible(x);
}

void test__sf__Window__setMouseCursorGrabbed__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setMouseCursorGrabbed(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setMouseCursorGrabbed__leakignore() {
  char *p = strdup(str);
  sf::Window::setMouseCursorGrabbed(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setMouseCursorGrabbed__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setMouseCursorGrabbed(x);
}

void test__sf__Window__setKeyRepeatEnabled__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setKeyRepeatEnabled(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setKeyRepeatEnabled__leakignore() {
  char *p = strdup(str);
  sf::Window::setKeyRepeatEnabled(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setKeyRepeatEnabled__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setKeyRepeatEnabled(x);
}

void test__sf__RenderWindow__setVisible__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setVisible(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setVisible__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setVisible(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setVisible__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setVisible(x);
}

void test__sf__RenderWindow__setVerticalSyncEnabled__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setVerticalSyncEnabled(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setVerticalSyncEnabled__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setVerticalSyncEnabled(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setVerticalSyncEnabled__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setVerticalSyncEnabled(x);
}

void test__sf__RenderWindow__setMouseCursorVisible__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setMouseCursorVisible(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setMouseCursorVisible__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setMouseCursorVisible(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setMouseCursorVisible__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setMouseCursorVisible(x);
}

void test__sf__RenderWindow__setMouseCursorGrabbed__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setMouseCursorGrabbed(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setMouseCursorGrabbed__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setMouseCursorGrabbed(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setMouseCursorGrabbed__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setMouseCursorGrabbed(x);
}

void test__sf__RenderWindow__setKeyRepeatEnabled__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setKeyRepeatEnabled(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setKeyRepeatEnabled__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setKeyRepeatEnabled(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setKeyRepeatEnabled__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setKeyRepeatEnabled(x);
}

void test__sf__Window__setFramerateLimit__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setFramerateLimit(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setFramerateLimit__leakignore() {
  char *p = strdup(str);
  sf::Window::setFramerateLimit(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setFramerateLimit__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setFramerateLimit(x);
}

void test__sf__RenderWindow__setFramerateLimit__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setFramerateLimit(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setFramerateLimit__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setFramerateLimit(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setFramerateLimit__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setFramerateLimit(x);
}

void test__sf__Window__setJoystickThreshold__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::setJoystickThreshold(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__setJoystickThreshold__leakignore() {
  char *p = strdup(str);
  sf::Window::setJoystickThreshold(p);
  // cppcheck-suppress memleak
}

void test__sf__Window__setJoystickThreshold__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::Window::setJoystickThreshold(x);
}

void test__sf__RenderWindow__setJoystickThreshold__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::setJoystickThreshold(arg1);
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__setJoystickThreshold__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::setJoystickThreshold(p);
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__setJoystickThreshold__arg1__notuninit() {
  int x;
  // cppcheck-suppress uninitvar
  sf::RenderWindow::setJoystickThreshold(x);
}

void test__sf__Window__requestFocus__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::requestFocus();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__requestFocus__leakignore() {
  char *p = strdup(str);
  sf::Window::requestFocus();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__requestFocus__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::requestFocus();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__requestFocus__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::requestFocus();
  // cppcheck-suppress memleak
}

void test__sf__Window__hasFocus__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::hasFocus();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__hasFocus__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::hasFocus();
}

void test__sf__Window__hasFocus__leakignore() {
  char *p = strdup(str);
  result = sf::Window::hasFocus();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__hasFocus__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::hasFocus();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__hasFocus__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::hasFocus();
}

void test__sf__RenderWindow__hasFocus__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::hasFocus();
  // cppcheck-suppress memleak
}

void test__sf__Window__display__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::Window::display();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__display__leakignore() {
  char *p = strdup(str);
  sf::Window::display();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__display__noreturn() {
  int x = 100;
  if (cond) x=1; else sf::RenderWindow::display();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__display__leakignore() {
  char *p = strdup(str);
  sf::RenderWindow::display();
  // cppcheck-suppress memleak
}

void test__sf__Window__getSystemHandle__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::Window::getSystemHandle();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__Window__getSystemHandle__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::Window::getSystemHandle();
}

void test__sf__Window__getSystemHandle__leakignore() {
  char *p = strdup(str);
  result = sf::Window::getSystemHandle();
  // cppcheck-suppress memleak
}

void test__sf__RenderWindow__getSystemHandle__noreturn() {
  int x = 100;
  if (cond) x=1; else result = sf::RenderWindow::getSystemHandle();
  // cppcheck-suppress shiftTooManyBits
  x = 1 << x;
}

void test__sf__RenderWindow__getSystemHandle__useretval() {
  // cppcheck-suppress ignoredReturnValue
  sf::RenderWindow::getSystemHandle();
}

void test__sf__RenderWindow__getSystemHandle__leakignore() {
  char *p = strdup(str);
  result = sf::RenderWindow::getSystemHandle();
  // cppcheck-suppress memleak
}