diff --git a/test/cfg/generated-cfg-tests-avr.cpp b/test/cfg/generated-cfg-tests-avr.cpp
index 9e6f1d49f..2ffd75ba3 100644
--- a/test/cfg/generated-cfg-tests-avr.cpp
+++ b/test/cfg/generated-cfg-tests-avr.cpp
@@ -16,7 +16,7 @@ void test__toascii__noreturn() {
 }
 
 void test__toascii__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   toascii(p);
   // cppcheck-suppress memleak
 }
@@ -29,7 +29,7 @@ void test__vfprintf_P__noreturn() {
 }
 
 void test__vfprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfprintf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -54,7 +54,7 @@ void test__printf_P__noreturn() {
 }
 
 void test__printf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   printf_P(p);
   // cppcheck-suppress memleak
 }
@@ -67,7 +67,7 @@ void test__sprintf_P__noreturn() {
 }
 
 void test__sprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sprintf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -80,7 +80,7 @@ void test__snprintf_P__noreturn() {
 }
 
 void test__snprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   snprintf_P(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -93,7 +93,7 @@ void test__vsprintf_P__noreturn() {
 }
 
 void test__vsprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsprintf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -106,7 +106,7 @@ void test__vsnprintf_P__noreturn() {
 }
 
 void test__vsnprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsnprintf_P(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -119,7 +119,7 @@ void test__fprintf_P__noreturn() {
 }
 
 void test__fprintf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fprintf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -144,7 +144,7 @@ void test__fputs_P__noreturn() {
 }
 
 void test__fputs_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fputs_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -181,7 +181,7 @@ void test__puts_P__noreturn() {
 }
 
 void test__puts_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   puts_P(p);
   // cppcheck-suppress memleak
 }
@@ -211,7 +211,7 @@ void test__scanf_P__noreturn() {
 }
 
 void test__scanf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   scanf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -230,7 +230,7 @@ void test__fscanf_P__noreturn() {
 }
 
 void test__fscanf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fscanf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -249,7 +249,7 @@ void test__sscanf_P__noreturn() {
 }
 
 void test__sscanf_P__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sscanf_P(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -293,7 +293,7 @@ void test__ltoa__noreturn() {
 }
 
 void test__ltoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ltoa(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -336,7 +336,7 @@ void test__utoa__noreturn() {
 }
 
 void test__utoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   utoa(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -379,7 +379,7 @@ void test__ultoa__noreturn() {
 }
 
 void test__ultoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ultoa(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -422,7 +422,7 @@ void test__random__noreturn() {
 }
 
 void test__random__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   random();
   // cppcheck-suppress memleak
 }
@@ -435,7 +435,7 @@ void test__random_r__noreturn() {
 }
 
 void test__random_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   random_r(p);
   // cppcheck-suppress memleak
 }
@@ -454,7 +454,7 @@ void test__srandom__noreturn() {
 }
 
 void test__srandom__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   srandom(p);
   // cppcheck-suppress memleak
 }
@@ -473,7 +473,7 @@ void test__dtostre__noreturn() {
 }
 
 void test__dtostre__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   dtostre(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -498,7 +498,7 @@ void test__dtostrf__noreturn() {
 }
 
 void test__dtostrf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   dtostrf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -535,7 +535,7 @@ void test__ffs__noreturn() {
 }
 
 void test__ffs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ffs(p);
   // cppcheck-suppress memleak
 }
@@ -554,7 +554,7 @@ void test__ffsl__noreturn() {
 }
 
 void test__ffsl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ffsl(p);
   // cppcheck-suppress memleak
 }
@@ -573,7 +573,7 @@ void test__ffsll__noreturn() {
 }
 
 void test__ffsll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ffsll(p);
   // cppcheck-suppress memleak
 }
@@ -592,7 +592,7 @@ void test__memccpy__noreturn() {
 }
 
 void test__memccpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memccpy(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-bsd.cpp b/test/cfg/generated-cfg-tests-bsd.cpp
index 0d3d689f1..1a605ced5 100644
--- a/test/cfg/generated-cfg-tests-bsd.cpp
+++ b/test/cfg/generated-cfg-tests-bsd.cpp
@@ -168,7 +168,7 @@ void test__readpassphrase__noreturn() {
 }
 
 void test__readpassphrase__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   readpassphrase(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -224,7 +224,7 @@ void test__strtonum__noreturn() {
 }
 
 void test__strtonum__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtonum(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-gnu.cpp b/test/cfg/generated-cfg-tests-gnu.cpp
index f4b545e26..c33bfcb04 100644
--- a/test/cfg/generated-cfg-tests-gnu.cpp
+++ b/test/cfg/generated-cfg-tests-gnu.cpp
@@ -16,7 +16,7 @@ void test__accept__noreturn() {
 }
 
 void test__accept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   accept(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -536,7 +536,7 @@ void test__strcasestr__pure(int arg1,int arg2) {
 }
 
 void test__strcasestr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strcasestr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -578,7 +578,7 @@ void test__getresuid__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__getresuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getresuid(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -614,7 +614,7 @@ void test__getresgid__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__getresgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getresgid(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -645,7 +645,7 @@ void test__setresuid__noreturn() {
 }
 
 void test__setresuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setresuid(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -676,7 +676,7 @@ void test__setresgid__noreturn() {
 }
 
 void test__setresgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setresgid(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -707,7 +707,7 @@ void test__inet_aton__noreturn() {
 }
 
 void test__inet_aton__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_aton(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -738,7 +738,7 @@ void test__inet_addr__noreturn() {
 }
 
 void test__inet_addr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_addr(p);
   // cppcheck-suppress memleak
 }
@@ -763,7 +763,7 @@ void test__inet_network__noreturn() {
 }
 
 void test__inet_network__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_network(p);
   // cppcheck-suppress memleak
 }
@@ -788,7 +788,7 @@ void test__inet_ntoa__noreturn() {
 }
 
 void test__inet_ntoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_ntoa(p);
   // cppcheck-suppress memleak
 }
@@ -807,7 +807,7 @@ void test__inet_makeaddr__noreturn() {
 }
 
 void test__inet_makeaddr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_makeaddr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -832,7 +832,7 @@ void test__inet_lnaof__noreturn() {
 }
 
 void test__inet_lnaof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_lnaof(p);
   // cppcheck-suppress memleak
 }
@@ -851,7 +851,7 @@ void test__inet_netof__noreturn() {
 }
 
 void test__inet_netof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_netof(p);
   // cppcheck-suppress memleak
 }
@@ -870,7 +870,7 @@ void test__inet_pton__noreturn() {
 }
 
 void test__inet_pton__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_pton(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -907,7 +907,7 @@ void test__inet_ntop__noreturn() {
 }
 
 void test__inet_ntop__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   inet_ntop(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -955,7 +955,7 @@ void test__canonicalize_file_name__useretval() {
 }
 
 void test__canonicalize_file_name__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = canonicalize_file_name(p);
   // cppcheck-suppress memleak
 }
@@ -974,7 +974,7 @@ void test__execvpe__noreturn() {
 }
 
 void test__execvpe__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   execvpe(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1011,7 +1011,7 @@ void test__mkostemp__noreturn() {
 }
 
 void test__mkostemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkostemp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1042,7 +1042,7 @@ void test__mkstemps__noreturn() {
 }
 
 void test__mkstemps__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkstemps(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1073,7 +1073,7 @@ void test__mkostemps__noreturn() {
 }
 
 void test__mkostemps__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkostemps(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1115,7 +1115,7 @@ void test__memmem__useretval() {
 }
 
 void test__memmem__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = memmem(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -1164,7 +1164,7 @@ void test__memrchr__noreturn() {
 }
 
 void test__memrchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memrchr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1205,7 +1205,7 @@ void test__rawmemchr__noreturn() {
 }
 
 void test__rawmemchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rawmemchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1246,7 +1246,7 @@ void test__ffsl__useretval() {
 }
 
 void test__ffsl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ffsl(p);
   // cppcheck-suppress memleak
 }
@@ -1270,7 +1270,7 @@ void test__ffsll__useretval() {
 }
 
 void test__ffsll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ffsll(p);
   // cppcheck-suppress memleak
 }
@@ -1294,7 +1294,7 @@ void test__strchrnul__useretval() {
 }
 
 void test__strchrnul__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strchrnul(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1325,7 +1325,7 @@ void test__prlimit__noreturn() {
 }
 
 void test__prlimit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   prlimit(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-motif.cpp b/test/cfg/generated-cfg-tests-motif.cpp
index 71eca1a53..7dd36bd5f 100644
--- a/test/cfg/generated-cfg-tests-motif.cpp
+++ b/test/cfg/generated-cfg-tests-motif.cpp
@@ -119,7 +119,7 @@ void test__XmStringCreateLocalized__useretval() {
 }
 
 void test__XmStringCreateLocalized__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = XmStringCreateLocalized(p);
   // cppcheck-suppress memleak
 }
@@ -149,7 +149,7 @@ void test__XmStringCreateSimple__useretval() {
 }
 
 void test__XmStringCreateSimple__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = XmStringCreateSimple(p);
   // cppcheck-suppress memleak
 }
@@ -187,7 +187,7 @@ void test__XmStringGenerate__noreturn() {
 }
 
 void test__XmStringGenerate__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XmStringGenerate(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -200,7 +200,7 @@ void test__XmTextGetString__noreturn() {
 }
 
 void test__XmTextGetString__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XmTextGetString(p);
   // cppcheck-suppress memleak
 }
@@ -219,7 +219,7 @@ void test__XmTextGetStringWcs__noreturn() {
 }
 
 void test__XmTextGetStringWcs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XmTextGetStringWcs(p);
   // cppcheck-suppress memleak
 }
@@ -263,7 +263,7 @@ void test__XtSetValues__noreturn() {
 }
 
 void test__XtSetValues__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtSetValues(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -276,7 +276,7 @@ void test__XtGetValues__noreturn() {
 }
 
 void test__XtGetValues__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtGetValues(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -289,7 +289,7 @@ void test__XtSetSubvalues__noreturn() {
 }
 
 void test__XtSetSubvalues__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtSetSubvalues(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -302,7 +302,7 @@ void test__XtGetSubvalues__noreturn() {
 }
 
 void test__XtGetSubvalues__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtGetSubvalues(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -393,7 +393,7 @@ void test__XOpenDisplay__noreturn() {
 }
 
 void test__XOpenDisplay__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XOpenDisplay(p);
   // cppcheck-suppress memleak
 }
@@ -412,7 +412,7 @@ void test__XCloseDisplay__noreturn() {
 }
 
 void test__XCloseDisplay__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XCloseDisplay(p);
   // cppcheck-suppress memleak
 }
@@ -431,7 +431,7 @@ void test__XtDatabase__noreturn() {
 }
 
 void test__XtDatabase__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtDatabase(p);
   // cppcheck-suppress memleak
 }
@@ -450,7 +450,7 @@ void test__XtScreenDatabase__noreturn() {
 }
 
 void test__XtScreenDatabase__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   XtScreenDatabase(p);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-posix.cpp b/test/cfg/generated-cfg-tests-posix.cpp
index 6689c277d..d8c3f2cdd 100644
--- a/test/cfg/generated-cfg-tests-posix.cpp
+++ b/test/cfg/generated-cfg-tests-posix.cpp
@@ -21,7 +21,7 @@ void test__a64l__useretval() {
 }
 
 void test__a64l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = a64l(p);
   // cppcheck-suppress memleak
 }
@@ -51,7 +51,7 @@ void test__l64a__useretval() {
 }
 
 void test__l64a__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = l64a(p);
   // cppcheck-suppress memleak
 }
@@ -70,7 +70,7 @@ void test__accept__noreturn() {
 }
 
 void test__accept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   accept(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -106,7 +106,7 @@ void test__access__useretval() {
 }
 
 void test__access__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = access(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -137,7 +137,7 @@ void test__adjtime__noreturn() {
 }
 
 void test__adjtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   adjtime(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -156,7 +156,7 @@ void test__gettimeofday__noreturn() {
 }
 
 void test__gettimeofday__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   gettimeofday(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -169,7 +169,7 @@ void test__settimeofday__noreturn() {
 }
 
 void test__settimeofday__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   settimeofday(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -194,7 +194,7 @@ void test__FD_CLR__noreturn() {
 }
 
 void test__FD_CLR__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   FD_CLR(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -219,7 +219,7 @@ void test__FD_ISSET__noreturn() {
 }
 
 void test__FD_ISSET__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   FD_ISSET(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -244,7 +244,7 @@ void test__FD_SET__noreturn() {
 }
 
 void test__FD_SET__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   FD_SET(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -269,7 +269,7 @@ void test__FD_ZERO__noreturn() {
 }
 
 void test__FD_ZERO__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   FD_ZERO(p);
   // cppcheck-suppress memleak
 }
@@ -288,7 +288,7 @@ void test__fdatasync__noreturn() {
 }
 
 void test__fdatasync__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fdatasync(p);
   // cppcheck-suppress memleak
 }
@@ -317,7 +317,7 @@ void test__fnmatch__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__fnmatch__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fnmatch(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -360,7 +360,7 @@ void test__fsync__noreturn() {
 }
 
 void test__fsync__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fsync(p);
   // cppcheck-suppress memleak
 }
@@ -379,7 +379,7 @@ void test__truncate__noreturn() {
 }
 
 void test__truncate__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   truncate(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -410,7 +410,7 @@ void test__ftruncate__noreturn() {
 }
 
 void test__ftruncate__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ftruncate(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -435,7 +435,7 @@ void test__flock__noreturn() {
 }
 
 void test__flock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   flock(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -460,7 +460,7 @@ void test__symlink__noreturn() {
 }
 
 void test__symlink__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   symlink(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -558,7 +558,7 @@ void test__sleep__noreturn() {
 }
 
 void test__sleep__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sleep(p);
   // cppcheck-suppress memleak
 }
@@ -582,7 +582,7 @@ void test__usleep__noreturn() {
 }
 
 void test__usleep__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   usleep(p);
   // cppcheck-suppress memleak
 }
@@ -613,7 +613,7 @@ void test__faccessat__noreturn() {
 }
 
 void test__faccessat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   faccessat(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -656,7 +656,7 @@ void test__acct__noreturn() {
 }
 
 void test__acct__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   acct(p);
   // cppcheck-suppress memleak
 }
@@ -675,7 +675,7 @@ void test__alarm__noreturn() {
 }
 
 void test__alarm__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   alarm(p);
   // cppcheck-suppress memleak
 }
@@ -699,7 +699,7 @@ void test__getrpcent__useretval() {
 }
 
 void test__getrpcent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getrpcent();
   // cppcheck-suppress memleak
 }
@@ -717,7 +717,7 @@ void test__getrpcbyname__useretval() {
 }
 
 void test__getrpcbyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getrpcbyname(p);
   // cppcheck-suppress memleak
 }
@@ -747,7 +747,7 @@ void test__getrpcbynumber__useretval() {
 }
 
 void test__getrpcbynumber__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getrpcbynumber(p);
   // cppcheck-suppress memleak
 }
@@ -771,7 +771,7 @@ void test__getprotoent__useretval() {
 }
 
 void test__getprotoent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getprotoent();
   // cppcheck-suppress memleak
 }
@@ -789,7 +789,7 @@ void test__getprotobyname__useretval() {
 }
 
 void test__getprotobyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getprotobyname(p);
   // cppcheck-suppress memleak
 }
@@ -819,7 +819,7 @@ void test__getprotobynumber__useretval() {
 }
 
 void test__getprotobynumber__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getprotobynumber(p);
   // cppcheck-suppress memleak
 }
@@ -843,7 +843,7 @@ void test__getservent__useretval() {
 }
 
 void test__getservent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getservent();
   // cppcheck-suppress memleak
 }
@@ -861,7 +861,7 @@ void test__getservbyname__useretval() {
 }
 
 void test__getservbyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getservbyname(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -897,7 +897,7 @@ void test__getservbyport__useretval() {
 }
 
 void test__getservbyport__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getservbyport(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -927,7 +927,7 @@ void test__getnetent__useretval() {
 }
 
 void test__getnetent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getnetent();
   // cppcheck-suppress memleak
 }
@@ -945,7 +945,7 @@ void test__getnetbyname__useretval() {
 }
 
 void test__getnetbyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getnetbyname(p);
   // cppcheck-suppress memleak
 }
@@ -975,7 +975,7 @@ void test__getnetbyaddr__useretval() {
 }
 
 void test__getnetbyaddr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getnetbyaddr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1005,7 +1005,7 @@ void test__gethostent__useretval() {
 }
 
 void test__gethostent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gethostent();
   // cppcheck-suppress memleak
 }
@@ -1023,7 +1023,7 @@ void test__gethostbyname__useretval() {
 }
 
 void test__gethostbyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gethostbyname(p);
   // cppcheck-suppress memleak
 }
@@ -1053,7 +1053,7 @@ void test__gethostbyname2__useretval() {
 }
 
 void test__gethostbyname2__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gethostbyname2(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1089,7 +1089,7 @@ void test__gethostbyaddr__useretval() {
 }
 
 void test__gethostbyaddr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gethostbyaddr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1126,7 +1126,7 @@ void test__brk__noreturn() {
 }
 
 void test__brk__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   brk(p);
   // cppcheck-suppress memleak
 }
@@ -1145,7 +1145,7 @@ void test__sbrk__noreturn() {
 }
 
 void test__sbrk__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sbrk(p);
   // cppcheck-suppress memleak
 }
@@ -1201,7 +1201,7 @@ void test__strsep__noreturn() {
 }
 
 void test__strsep__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strsep(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1301,7 +1301,7 @@ void test__mkstemp__noreturn() {
 }
 
 void test__mkstemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkstemp(p);
   // cppcheck-suppress memleak
 }
@@ -1326,7 +1326,7 @@ void test__mkdtemp__noreturn() {
 }
 
 void test__mkdtemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkdtemp(p);
   // cppcheck-suppress memleak
 }
@@ -1356,7 +1356,7 @@ void test__mktemp__useretval() {
 }
 
 void test__mktemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = mktemp(p);
   // cppcheck-suppress memleak
 }
@@ -1381,7 +1381,7 @@ void test__getcwd__noreturn() {
 }
 
 void test__getcwd__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getcwd(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1406,7 +1406,7 @@ void test__mkdir__noreturn() {
 }
 
 void test__mkdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkdir(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1437,7 +1437,7 @@ void test__rmdir__noreturn() {
 }
 
 void test__rmdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rmdir(p);
   // cppcheck-suppress memleak
 }
@@ -1462,7 +1462,7 @@ void test__chdir__noreturn() {
 }
 
 void test__chdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   chdir(p);
   // cppcheck-suppress memleak
 }
@@ -1487,7 +1487,7 @@ void test__chroot__noreturn() {
 }
 
 void test__chroot__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   chroot(p);
   // cppcheck-suppress memleak
 }
@@ -1512,7 +1512,7 @@ void test__link__noreturn() {
 }
 
 void test__link__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   link(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1549,7 +1549,7 @@ void test__unlink__noreturn() {
 }
 
 void test__unlink__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   unlink(p);
   // cppcheck-suppress memleak
 }
@@ -1574,7 +1574,7 @@ void test__rename__noreturn() {
 }
 
 void test__rename__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rename(p);
   // cppcheck-suppress memleak
 }
@@ -1599,7 +1599,7 @@ void test__stat__noreturn() {
 }
 
 void test__stat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   stat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1630,7 +1630,7 @@ void test__lstat__noreturn() {
 }
 
 void test__lstat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   lstat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1661,7 +1661,7 @@ void test__fstat__noreturn() {
 }
 
 void test__fstat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fstat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1686,7 +1686,7 @@ void test__chmod__noreturn() {
 }
 
 void test__chmod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   chmod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1717,7 +1717,7 @@ void test__fchmod__noreturn() {
 }
 
 void test__fchmod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fchmod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1742,7 +1742,7 @@ void test__chown__noreturn() {
 }
 
 void test__chown__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   chown(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1779,7 +1779,7 @@ void test__lchown__noreturn() {
 }
 
 void test__lchown__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   lchown(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1816,7 +1816,7 @@ void test__fchown__noreturn() {
 }
 
 void test__fchown__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fchown(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1847,7 +1847,7 @@ void test__times__noreturn() {
 }
 
 void test__times__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   times(p);
   // cppcheck-suppress memleak
 }
@@ -1866,7 +1866,7 @@ void test__utime__noreturn() {
 }
 
 void test__utime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   utime(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1897,7 +1897,7 @@ void test__utimes__noreturn() {
 }
 
 void test__utimes__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   utimes(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1975,7 +1975,7 @@ void test__isatty__useretval() {
 }
 
 void test__isatty__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isatty(p);
   // cppcheck-suppress memleak
 }
@@ -2074,7 +2074,7 @@ void test__nice__noreturn() {
 }
 
 void test__nice__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   nice(p);
   // cppcheck-suppress memleak
 }
@@ -2093,7 +2093,7 @@ void test__pause__noreturn() {
 }
 
 void test__pause__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   pause();
   // cppcheck-suppress memleak
 }
@@ -2119,7 +2119,7 @@ void test__confstr__noreturn() {
 }
 
 void test__confstr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   confstr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -2150,7 +2150,7 @@ void test__fpathconf__noreturn() {
 }
 
 void test__fpathconf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fpathconf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2175,7 +2175,7 @@ void test__pathconf__noreturn() {
 }
 
 void test__pathconf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   pathconf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2206,7 +2206,7 @@ void test__sysconf__noreturn() {
 }
 
 void test__sysconf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sysconf(p);
   // cppcheck-suppress memleak
 }
@@ -2274,7 +2274,7 @@ void test__rewinddir__noreturn() {
 }
 
 void test__rewinddir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rewinddir(p);
   // cppcheck-suppress memleak
 }
@@ -2299,7 +2299,7 @@ void test__seekdir__noreturn() {
 }
 
 void test__seekdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   seekdir(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2330,7 +2330,7 @@ void test__rand_r__noreturn() {
 }
 
 void test__rand_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rand_r(p);
   // cppcheck-suppress memleak
 }
@@ -2354,7 +2354,7 @@ void test__strcasecmp__pure(int arg1,int arg2) {
 }
 
 void test__strcasecmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strcasecmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2396,7 +2396,7 @@ void test__strncasecmp__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__strncasecmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strncasecmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -2431,7 +2431,7 @@ void test__strncasecmp__arg3__notbool() {
 }
 
 void test__read__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   read(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -2456,7 +2456,7 @@ void test__write__noreturn() {
 }
 
 void test__write__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   write(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -2594,7 +2594,7 @@ void test__mmap__useretval() {
 }
 
 void test__mmap__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = mmap(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -2648,7 +2648,7 @@ void test__mmap64__useretval() {
 }
 
 void test__mmap64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = mmap64(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -2722,7 +2722,7 @@ void test__openlog__noreturn() {
 }
 
 void test__openlog__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   openlog(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -2753,7 +2753,7 @@ void test__fcntl__noreturn() {
 }
 
 void test__fcntl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fcntl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2778,7 +2778,7 @@ void test__ioctl__noreturn() {
 }
 
 void test__ioctl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ioctl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2803,7 +2803,7 @@ void test__syslog__noreturn() {
 }
 
 void test__syslog__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   syslog(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2822,7 +2822,7 @@ void test__vsyslog__noreturn() {
 }
 
 void test__vsyslog__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsyslog(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2870,7 +2870,7 @@ void test__getuid__useretval() {
 }
 
 void test__getuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getuid();
   // cppcheck-suppress memleak
 }
@@ -2888,7 +2888,7 @@ void test__getsid__useretval() {
 }
 
 void test__getsid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getsid(p);
   // cppcheck-suppress memleak
 }
@@ -2912,7 +2912,7 @@ void test__geteuid__useretval() {
 }
 
 void test__geteuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = geteuid();
   // cppcheck-suppress memleak
 }
@@ -2930,7 +2930,7 @@ void test__getppid__useretval() {
 }
 
 void test__getppid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getppid();
   // cppcheck-suppress memleak
 }
@@ -2948,7 +2948,7 @@ void test__getpid__useretval() {
 }
 
 void test__getpid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getpid();
   // cppcheck-suppress memleak
 }
@@ -2966,7 +2966,7 @@ void test__getpgrp__useretval() {
 }
 
 void test__getpgrp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getpgrp();
   // cppcheck-suppress memleak
 }
@@ -2984,7 +2984,7 @@ void test__getpgid__useretval() {
 }
 
 void test__getpgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getpgid(p);
   // cppcheck-suppress memleak
 }
@@ -3008,7 +3008,7 @@ void test__setuid__useretval() {
 }
 
 void test__setuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = setuid(p);
   // cppcheck-suppress memleak
 }
@@ -3032,7 +3032,7 @@ void test__seteuid__useretval() {
 }
 
 void test__seteuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = seteuid(p);
   // cppcheck-suppress memleak
 }
@@ -3056,7 +3056,7 @@ void test__setgid__useretval() {
 }
 
 void test__setgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = setgid(p);
   // cppcheck-suppress memleak
 }
@@ -3080,7 +3080,7 @@ void test__setegid__useretval() {
 }
 
 void test__setegid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = setegid(p);
   // cppcheck-suppress memleak
 }
@@ -3170,7 +3170,7 @@ void test__setfsuid__noreturn() {
 }
 
 void test__setfsuid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setfsuid(p);
   // cppcheck-suppress memleak
 }
@@ -3189,7 +3189,7 @@ void test__setfsgid__noreturn() {
 }
 
 void test__setfsgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setfsgid(p);
   // cppcheck-suppress memleak
 }
@@ -3215,7 +3215,7 @@ void test__getwd__noreturn() {
 }
 
 void test__getwd__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getwd(p);
   // cppcheck-suppress memleak
 }
@@ -3780,7 +3780,7 @@ void test__strtok_r__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__strtok_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtok_r(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4317,7 +4317,7 @@ void test__lseek__noreturn() {
 }
 
 void test__lseek__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   lseek(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4348,7 +4348,7 @@ void test__nanosleep__noreturn() {
 }
 
 void test__nanosleep__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   nanosleep(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4367,7 +4367,7 @@ void test__setkey__noreturn() {
 }
 
 void test__setkey__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setkey(p);
   // cppcheck-suppress memleak
 }
@@ -4392,7 +4392,7 @@ void test__getpass__noreturn() {
 }
 
 void test__getpass__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getpass(p);
   // cppcheck-suppress memleak
 }
@@ -4498,7 +4498,7 @@ void test__localtime__noreturn() {
 }
 
 void test__localtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   localtime(p);
   // cppcheck-suppress memleak
 }
@@ -4522,12 +4522,6 @@ void test__std__localtime__noreturn() {
   x = 1 << x;
 }
 
-void test__std__localtime__leakignore() {
-  char *p = strdup(str);
-  std::localtime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__localtime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4548,7 +4542,7 @@ void test__localtime_r__noreturn() {
 }
 
 void test__localtime_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   localtime_r(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4579,7 +4573,7 @@ void test__readdir__noreturn() {
 }
 
 void test__readdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   readdir(p);
   // cppcheck-suppress memleak
 }
@@ -4604,7 +4598,7 @@ void test__readdir_r__noreturn() {
 }
 
 void test__readdir_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   readdir_r(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4641,7 +4635,7 @@ void test__readlink__noreturn() {
 }
 
 void test__readlink__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   readlink(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4678,7 +4672,7 @@ void test__readlinkat__noreturn() {
 }
 
 void test__readlinkat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   readlinkat(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -4721,7 +4715,7 @@ void test__asctime_r__noreturn() {
 }
 
 void test__asctime_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   asctime_r(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4752,7 +4746,7 @@ void test__ctime_r__noreturn() {
 }
 
 void test__ctime_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ctime_r(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4783,7 +4777,7 @@ void test__gmtime_r__noreturn() {
 }
 
 void test__gmtime_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   gmtime_r(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4819,7 +4813,7 @@ void test__gmtime__useretval() {
 }
 
 void test__gmtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gmtime(p);
   // cppcheck-suppress memleak
 }
@@ -4933,7 +4927,7 @@ void test__tmpnam__noreturn() {
 }
 
 void test__tmpnam__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tmpnam(p);
   // cppcheck-suppress memleak
 }
@@ -4952,7 +4946,7 @@ void test__tmpnam_r__noreturn() {
 }
 
 void test__tmpnam_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tmpnam_r(p);
   // cppcheck-suppress memleak
 }
@@ -4971,7 +4965,7 @@ void test__makecontext__noreturn() {
 }
 
 void test__makecontext__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   makecontext(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5008,7 +5002,7 @@ void test__swapcontext__noreturn() {
 }
 
 void test__swapcontext__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   swapcontext(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5033,7 +5027,7 @@ void test__getcontext__noreturn() {
 }
 
 void test__getcontext__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getcontext(p);
   // cppcheck-suppress memleak
 }
@@ -5052,7 +5046,7 @@ void test__ualarm__noreturn() {
 }
 
 void test__ualarm__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ualarm(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5082,7 +5076,7 @@ void test__scalb__useretval() {
 }
 
 void test__scalb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalb(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5107,7 +5101,7 @@ void test__bcopy__noreturn() {
 }
 
 void test__bcopy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   bcopy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5149,7 +5143,7 @@ void test__bcmp__useretval() {
 }
 
 void test__bcmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = bcmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5192,7 +5186,7 @@ void test__bzero__noreturn() {
 }
 
 void test__bzero__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   bzero(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5217,7 +5211,7 @@ void test__ftime__noreturn() {
 }
 
 void test__ftime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ftime(p);
   // cppcheck-suppress memleak
 }
@@ -5241,7 +5235,7 @@ void test__wcswcs__useretval() {
 }
 
 void test__wcswcs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcswcs(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5278,7 +5272,7 @@ void test__stpcpy__noreturn() {
 }
 
 void test__stpcpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   stpcpy(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5314,7 +5308,7 @@ void test__index__useretval() {
 }
 
 void test__index__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = index(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5350,7 +5344,7 @@ void test__rindex__useretval() {
 }
 
 void test__rindex__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = rindex(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5381,7 +5375,7 @@ void test__bsd_signal__noreturn() {
 }
 
 void test__bsd_signal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   bsd_signal(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5406,7 +5400,7 @@ void test__fork__noreturn() {
 }
 
 void test__fork__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fork();
   // cppcheck-suppress memleak
 }
@@ -5419,7 +5413,7 @@ void test__vfork__noreturn() {
 }
 
 void test__vfork__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfork();
   // cppcheck-suppress memleak
 }
@@ -5432,7 +5426,7 @@ void test__pthread_atfork__noreturn() {
 }
 
 void test__pthread_atfork__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   pthread_atfork(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5578,7 +5572,7 @@ void test__pthread_attr_setstackaddr__noreturn() {
 }
 
 void test__pthread_attr_setstackaddr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   pthread_attr_setstackaddr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5615,7 +5609,7 @@ void test__pthread_attr_getstackaddr__noreturn() {
 }
 
 void test__pthread_attr_getstackaddr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   pthread_attr_getstackaddr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5651,7 +5645,7 @@ void test__tempnam__useretval() {
 }
 
 void test__tempnam__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tempnam(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5681,7 +5675,7 @@ void test__crypt__useretval() {
 }
 
 void test__crypt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = crypt(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5723,7 +5717,7 @@ void test__ttyname__useretval() {
 }
 
 void test__ttyname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ttyname(p);
   // cppcheck-suppress memleak
 }
@@ -5747,7 +5741,7 @@ void test__getspnam__useretval() {
 }
 
 void test__getspnam__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getspnam(p);
   // cppcheck-suppress memleak
 }
@@ -5777,7 +5771,7 @@ void test__getspent__useretval() {
 }
 
 void test__getspent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getspent();
   // cppcheck-suppress memleak
 }
@@ -5795,7 +5789,7 @@ void test__fgetspent__useretval() {
 }
 
 void test__fgetspent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fgetspent(p);
   // cppcheck-suppress memleak
 }
@@ -5825,7 +5819,7 @@ void test__sgetspent__useretval() {
 }
 
 void test__sgetspent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sgetspent(p);
   // cppcheck-suppress memleak
 }
@@ -5855,7 +5849,7 @@ void test__fgetpwent__useretval() {
 }
 
 void test__fgetpwent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fgetpwent(p);
   // cppcheck-suppress memleak
 }
@@ -5885,7 +5879,7 @@ void test__getgrent__useretval() {
 }
 
 void test__getgrent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getgrent();
   // cppcheck-suppress memleak
 }
@@ -5903,7 +5897,7 @@ void test__getgrent_r__useretval() {
 }
 
 void test__getgrent_r__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getgrent_r(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5933,7 +5927,7 @@ void test__fgetgrent__useretval() {
 }
 
 void test__fgetgrent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fgetgrent(p);
   // cppcheck-suppress memleak
 }
@@ -5958,7 +5952,7 @@ void test__getnetgrent__noreturn() {
 }
 
 void test__getnetgrent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getnetgrent(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5994,7 +5988,7 @@ void test__getgrnam__useretval() {
 }
 
 void test__getgrnam__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getgrnam(p);
   // cppcheck-suppress memleak
 }
@@ -6024,7 +6018,7 @@ void test__getgrgid__useretval() {
 }
 
 void test__getgrgid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getgrgid(p);
   // cppcheck-suppress memleak
 }
@@ -6048,7 +6042,7 @@ void test__getlogin__useretval() {
 }
 
 void test__getlogin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getlogin();
   // cppcheck-suppress memleak
 }
@@ -6061,7 +6055,7 @@ void test__ctermid__noreturn() {
 }
 
 void test__ctermid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ctermid(p);
   // cppcheck-suppress memleak
 }
@@ -6074,7 +6068,7 @@ void test__realpath__noreturn() {
 }
 
 void test__realpath__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   realpath(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6099,7 +6093,7 @@ void test__remove__noreturn() {
 }
 
 void test__remove__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   remove(p);
   // cppcheck-suppress memleak
 }
@@ -6129,7 +6123,7 @@ void test__fileno__useretval() {
 }
 
 void test__fileno__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fileno(p);
   // cppcheck-suppress memleak
 }
@@ -6154,7 +6148,7 @@ void test__fseeko__noreturn() {
 }
 
 void test__fseeko__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fseeko(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6196,7 +6190,7 @@ void test__ftello__useretval() {
 }
 
 void test__ftello__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ftello(p);
   // cppcheck-suppress memleak
 }
@@ -6221,7 +6215,7 @@ void test__execv__noreturn() {
 }
 
 void test__execv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   execv(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6252,7 +6246,7 @@ void test__execvp__noreturn() {
 }
 
 void test__execvp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   execvp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6283,7 +6277,7 @@ void test__wait__noreturn() {
 }
 
 void test__wait__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wait(p);
   // cppcheck-suppress memleak
 }
@@ -6296,7 +6290,7 @@ void test__waitpid__noreturn() {
 }
 
 void test__waitpid__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   waitpid(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6326,7 +6320,7 @@ void test__strnlen__useretval() {
 }
 
 void test__strnlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strnlen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6362,7 +6356,7 @@ void test__wcsnlen__useretval() {
 }
 
 void test__wcsnlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsnlen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6398,7 +6392,7 @@ void test__ffs__useretval() {
 }
 
 void test__ffs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ffs(p);
   // cppcheck-suppress memleak
 }
@@ -6417,7 +6411,7 @@ void test__shmctl__noreturn() {
 }
 
 void test__shmctl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   shmctl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6442,7 +6436,7 @@ void test__shmget__noreturn() {
 }
 
 void test__shmget__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   shmget(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6473,7 +6467,7 @@ void test__shmat__noreturn() {
 }
 
 void test__shmat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   shmat(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6498,7 +6492,7 @@ void test__shmdt__noreturn() {
 }
 
 void test__shmdt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   shmdt(p);
   // cppcheck-suppress memleak
 }
@@ -6511,7 +6505,7 @@ void test__getrlimit__noreturn() {
 }
 
 void test__getrlimit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getrlimit(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6536,7 +6530,7 @@ void test__setrlimit__noreturn() {
 }
 
 void test__setrlimit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setrlimit(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6623,7 +6617,7 @@ void test__wcpncpy__noreturn() {
 }
 
 void test__wcpncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcpncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6665,7 +6659,7 @@ void test__stpncpy__noreturn() {
 }
 
 void test__stpncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   stpncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6707,7 +6701,7 @@ void test__memccpy__noreturn() {
 }
 
 void test__memccpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memccpy(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -6750,7 +6744,7 @@ void test__getopt__noreturn() {
 }
 
 void test__getopt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getopt(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6793,7 +6787,7 @@ void test__getitimer__noreturn() {
 }
 
 void test__getitimer__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getitimer(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6824,7 +6818,7 @@ void test__setitimer__noreturn() {
 }
 
 void test__setitimer__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setitimer(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6855,7 +6849,7 @@ void test__sigaction__noreturn() {
 }
 
 void test__sigaction__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigaction(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6874,7 +6868,7 @@ void test__sigaltstack__noreturn() {
 }
 
 void test__sigaltstack__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigaltstack(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6957,7 +6951,7 @@ void test__sigsuspend__noreturn() {
 }
 
 void test__sigsuspend__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigsuspend(p);
   // cppcheck-suppress memleak
 }
@@ -7026,7 +7020,7 @@ void test__getrusage__noreturn() {
 }
 
 void test__getrusage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getrusage(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7051,7 +7045,7 @@ void test__sigemptyset__noreturn() {
 }
 
 void test__sigemptyset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigemptyset(p);
   // cppcheck-suppress memleak
 }
@@ -7070,7 +7064,7 @@ void test__sigfillset__noreturn() {
 }
 
 void test__sigfillset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigfillset(p);
   // cppcheck-suppress memleak
 }
@@ -7089,7 +7083,7 @@ void test__sigaddset__noreturn() {
 }
 
 void test__sigaddset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigaddset(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7114,7 +7108,7 @@ void test__sigdelset__noreturn() {
 }
 
 void test__sigdelset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigdelset(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7139,7 +7133,7 @@ void test__sigismember__noreturn() {
 }
 
 void test__sigismember__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sigismember(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7164,7 +7158,7 @@ void test__posix_spawn__noreturn() {
 }
 
 void test__posix_spawn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   posix_spawn(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -7177,7 +7171,7 @@ void test__posix_spawnp__noreturn() {
 }
 
 void test__posix_spawnp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   posix_spawnp(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -7190,7 +7184,7 @@ void test__msgctl__noreturn() {
 }
 
 void test__msgctl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   msgctl(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -7245,7 +7239,7 @@ void test__msgrcv__noreturn() {
 }
 
 void test__msgrcv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   msgrcv(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -7288,7 +7282,7 @@ void test__msgsnd__noreturn() {
 }
 
 void test__msgsnd__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   msgsnd(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -7325,7 +7319,7 @@ void test__tcflow__noreturn() {
 }
 
 void test__tcflow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcflow(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7350,7 +7344,7 @@ void test__tcflush__noreturn() {
 }
 
 void test__tcflush__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcflush(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7375,7 +7369,7 @@ void test__tcsendbreak__noreturn() {
 }
 
 void test__tcsendbreak__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcsendbreak(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7400,7 +7394,7 @@ void test__tcgetattr__noreturn() {
 }
 
 void test__tcgetattr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcgetattr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7425,7 +7419,7 @@ void test__tcsetattr__noreturn() {
 }
 
 void test__tcsetattr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcsetattr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -7462,7 +7456,7 @@ void test__cfsetospeed__noreturn() {
 }
 
 void test__cfsetospeed__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   cfsetospeed(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7493,7 +7487,7 @@ void test__cfsetispeed__noreturn() {
 }
 
 void test__cfsetispeed__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   cfsetispeed(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7524,7 +7518,7 @@ void test__tcdrain__noreturn() {
 }
 
 void test__tcdrain__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tcdrain(p);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-qt.cpp b/test/cfg/generated-cfg-tests-qt.cpp
index 1aaf11d50..723162687 100644
--- a/test/cfg/generated-cfg-tests-qt.cpp
+++ b/test/cfg/generated-cfg-tests-qt.cpp
@@ -107,7 +107,7 @@ void test__tr__useretval() {
 }
 
 void test__tr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -148,12 +148,6 @@ void test__QObject__tr__useretval() {
   QObject::tr(arg1, arg2, arg3);
 }
 
-void test__QObject__tr__leakignore() {
-  char *p = strdup(str);
-  result = QObject::tr(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__QObject__tr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -185,12 +179,6 @@ void test__QSettings__setValue__noreturn() {
   x = 1 << x;
 }
 
-void test__QSettings__setValue__leakignore() {
-  char *p = strdup(str);
-  QSettings::setValue(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__QSettings__setValue__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -246,12 +234,6 @@ void test__QString__sprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__QString__sprintf__leakignore() {
-  char *p = strdup(str);
-  QString::sprintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__sprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -265,12 +247,6 @@ void test__QString__asprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__QString__asprintf__leakignore() {
-  char *p = strdup(str);
-  QString::asprintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__asprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -742,12 +718,6 @@ void test__QString__compare__useretval() {
   QString::compare(arg1, arg2, arg3);
 }
 
-void test__QString__compare__leakignore() {
-  char *p = strdup(str);
-  result = QString::compare(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__compare__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1366,12 +1336,6 @@ void test__QString__number__useretval() {
   QString::number();
 }
 
-void test__QString__number__leakignore() {
-  char *p = strdup(str);
-  result = QString::number();
-  // cppcheck-suppress memleak
-}
-
 void test__QString__right__noreturn() {
   int x = 1;
   if (cond) { x=100; result = QString::right(arg1); }
@@ -1384,12 +1348,6 @@ void test__QString__right__useretval() {
   QString::right(arg1);
 }
 
-void test__QString__right__leakignore() {
-  char *p = strdup(str);
-  result = QString::right(p);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__right__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   result = QString::right(!x);
@@ -1413,12 +1371,6 @@ void test__QString__split__useretval() {
   QString::split(arg1);
 }
 
-void test__QString__split__leakignore() {
-  char *p = strdup(str);
-  result = QString::split(p);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__split__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1437,12 +1389,6 @@ void test__QString__toInt__useretval() {
   QString::toInt(arg1, arg2);
 }
 
-void test__QString__toInt__leakignore() {
-  char *p = strdup(str);
-  result = QString::toInt(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__QString__toInt__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1522,12 +1468,6 @@ void test__QMetaObject__connectSlotsByName__noreturn() {
   x = 1 << x;
 }
 
-void test__QMetaObject__connectSlotsByName__leakignore() {
-  char *p = strdup(str);
-  QMetaObject::connectSlotsByName(p);
-  // cppcheck-suppress memleak
-}
-
 void test__QMetaObject__connectSlotsByName__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -1577,12 +1517,6 @@ void test__QFile__open__noreturn() {
   x = 1 << x;
 }
 
-void test__QFile__open__leakignore() {
-  char *p = strdup(str);
-  QFile::open();
-  // cppcheck-suppress memleak
-}
-
 void test__QFile__remove__noreturn() {
   int x = 1;
   if (cond) { x=100; QFile::remove(); }
@@ -1590,12 +1524,6 @@ void test__QFile__remove__noreturn() {
   x = 1 << x;
 }
 
-void test__QFile__remove__leakignore() {
-  char *p = strdup(str);
-  QFile::remove();
-  // cppcheck-suppress memleak
-}
-
 void test__QFile__rename__noreturn() {
   int x = 1;
   if (cond) { x=100; QFile::rename(); }
@@ -1603,12 +1531,6 @@ void test__QFile__rename__noreturn() {
   x = 1 << x;
 }
 
-void test__QFile__rename__leakignore() {
-  char *p = strdup(str);
-  QFile::rename();
-  // cppcheck-suppress memleak
-}
-
 void test__QFile__size__noreturn() {
   int x = 1;
   if (cond) { x=100; result = QFile::size(); }
diff --git a/test/cfg/generated-cfg-tests-sfml.cpp b/test/cfg/generated-cfg-tests-sfml.cpp
index dc75c735e..8187f332e 100644
--- a/test/cfg/generated-cfg-tests-sfml.cpp
+++ b/test/cfg/generated-cfg-tests-sfml.cpp
@@ -20,12 +20,6 @@ void test__sf__err__useretval() {
   sf::err();
 }
 
-void test__sf__err__leakignore() {
-  char *p = strdup(str);
-  result = sf::err();
-  // cppcheck-suppress memleak
-}
-
 void test__sf__sleep__noreturn() {
   int x = 1;
   if (cond) { x=100; sf::sleep(arg1); }
@@ -33,12 +27,6 @@ void test__sf__sleep__noreturn() {
   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
@@ -57,12 +45,6 @@ void test__sf__Time__asSeconds__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::Time::asMilliseconds(); }
@@ -75,12 +57,6 @@ void test__sf__Time__asMilliseconds__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::Time::asMicroseconds(); }
@@ -93,12 +69,6 @@ void test__sf__Time__asMicroseconds__useretval() {
   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 = 1;
   if (cond) { x=100; sf::String::clear(); }
@@ -106,12 +76,6 @@ void test__sf__String__clear__noreturn() {
   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 = 1;
   if (cond) { x=100; result = sf::String::isEmpty(); }
@@ -124,12 +88,6 @@ void test__sf__String__isEmpty__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::String::getSize(); }
@@ -142,12 +100,6 @@ void test__sf__String__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; sf::String::find(arg1, arg2); }
@@ -155,12 +107,6 @@ void test__sf__String__find__noreturn() {
   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() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -191,12 +137,6 @@ void test__sf__String__substring__useretval() {
   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
@@ -216,12 +156,6 @@ void test__sf__String__erase__noreturn() {
   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
@@ -241,12 +175,6 @@ void test__sf__RenderTarget__clear__noreturn() {
   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
@@ -260,12 +188,6 @@ void test__sf__RenderWindow__clear__noreturn() {
   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
@@ -279,12 +201,6 @@ void test__sf__RenderTexture__clear__noreturn() {
   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
@@ -298,12 +214,6 @@ void test__sf__RenderTarget__setView__noreturn() {
   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
@@ -317,12 +227,6 @@ void test__sf__RenderWindow__setView__noreturn() {
   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
@@ -336,12 +240,6 @@ void test__sf__RenderTexture__setView__noreturn() {
   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
@@ -360,12 +258,6 @@ void test__sf__RenderTarget__getView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderTarget::getDefaultView(); }
@@ -378,12 +270,6 @@ void test__sf__RenderTarget__getDefaultView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getView(); }
@@ -396,12 +282,6 @@ void test__sf__RenderWindow__getView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getDefaultView(); }
@@ -414,12 +294,6 @@ void test__sf__RenderWindow__getDefaultView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderTexture::getView(); }
@@ -432,12 +306,6 @@ void test__sf__RenderTexture__getView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderTexture::getDefaultView(); }
@@ -450,12 +318,6 @@ void test__sf__RenderTexture__getDefaultView__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderTarget::getViewport(arg1); }
@@ -468,12 +330,6 @@ void test__sf__RenderTarget__getViewport__useretval() {
   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
@@ -492,12 +348,6 @@ void test__sf__RenderWindow__getViewport__useretval() {
   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
@@ -516,12 +366,6 @@ void test__sf__RenderTexture__getViewport__useretval() {
   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
@@ -540,12 +384,6 @@ void test__sf__RenderTarget__mapPixelToCoords__useretval() {
   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
@@ -570,12 +408,6 @@ void test__sf__RenderTarget__mapCoordsToPixel__useretval() {
   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
@@ -600,12 +432,6 @@ void test__sf__RenderWindow__mapPixelToCoords__useretval() {
   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
@@ -630,12 +456,6 @@ void test__sf__RenderWindow__mapCoordsToPixel__useretval() {
   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
@@ -660,12 +480,6 @@ void test__sf__RenderTexture__mapPixelToCoords__useretval() {
   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
@@ -690,12 +504,6 @@ void test__sf__RenderTexture__mapCoordsToPixel__useretval() {
   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
@@ -715,12 +523,6 @@ void test__sf__RenderTarget__draw__noreturn() {
   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
@@ -752,12 +554,6 @@ void test__sf__RenderWindow__draw__noreturn() {
   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
@@ -789,12 +585,6 @@ void test__sf__RenderTexture__draw__noreturn() {
   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
@@ -831,12 +621,6 @@ void test__sf__RenderTarget__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getSize(); }
@@ -849,12 +633,6 @@ void test__sf__RenderWindow__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderTexture::getSize(); }
@@ -867,12 +645,6 @@ void test__sf__RenderTexture__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; sf::RenderTarget::setActive(arg1); }
@@ -880,12 +652,6 @@ void test__sf__RenderTarget__setActive__noreturn() {
   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
@@ -899,12 +665,6 @@ void test__sf__RenderWindow__setActive__noreturn() {
   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
@@ -918,12 +678,6 @@ void test__sf__RenderTexture__setActive__noreturn() {
   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
@@ -937,12 +691,6 @@ void test__sf__Window__setActive__noreturn() {
   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
@@ -956,12 +704,6 @@ void test__sf__RenderTarget__pushGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderTarget::popGLStates(); }
@@ -969,12 +711,6 @@ void test__sf__RenderTarget__popGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderTarget::resetGLStates(); }
@@ -982,12 +718,6 @@ void test__sf__RenderTarget__resetGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::pushGLStates(); }
@@ -995,12 +725,6 @@ void test__sf__RenderWindow__pushGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::popGLStates(); }
@@ -1008,12 +732,6 @@ void test__sf__RenderWindow__popGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::resetGLStates(); }
@@ -1021,12 +739,6 @@ void test__sf__RenderWindow__resetGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderTexture::pushGLStates(); }
@@ -1034,12 +746,6 @@ void test__sf__RenderTexture__pushGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderTexture::popGLStates(); }
@@ -1047,12 +753,6 @@ void test__sf__RenderTexture__popGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderTexture::resetGLStates(); }
@@ -1060,12 +760,6 @@ void test__sf__RenderTexture__resetGLStates__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::Window::create(arg1, arg2, arg3, arg4); }
@@ -1073,12 +767,6 @@ void test__sf__Window__create__noreturn() {
   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
@@ -1110,12 +798,6 @@ void test__sf__RenderWindow__create__noreturn() {
   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
@@ -1147,12 +829,6 @@ void test__sf__Window__close__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::close(); }
@@ -1160,12 +836,6 @@ void test__sf__RenderWindow__close__noreturn() {
   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 = 1;
   if (cond) { x=100; result = sf::Window::isOpen(); }
@@ -1178,12 +848,6 @@ void test__sf__Window__isOpen__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::isOpen(); }
@@ -1196,12 +860,6 @@ void test__sf__RenderWindow__isOpen__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::Window::getSettings(); }
@@ -1214,12 +872,6 @@ void test__sf__Window__getSettings__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getSettings(); }
@@ -1232,12 +884,6 @@ void test__sf__RenderWindow__getSettings__useretval() {
   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 = 1;
   if (cond) { x=100; sf::Window::pollEvent(arg1); }
@@ -1245,12 +891,6 @@ void test__sf__Window__pollEvent__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::Window::waitEvent(arg1); }
@@ -1258,12 +898,6 @@ void test__sf__Window__waitEvent__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::pollEvent(arg1); }
@@ -1271,12 +905,6 @@ void test__sf__RenderWindow__pollEvent__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::waitEvent(arg1); }
@@ -1284,12 +912,6 @@ void test__sf__RenderWindow__waitEvent__noreturn() {
   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 = 1;
   if (cond) { x=100; result = sf::Window::getPosition(); }
@@ -1302,12 +924,6 @@ void test__sf__Window__getPosition__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getPosition(); }
@@ -1320,12 +936,6 @@ void test__sf__RenderWindow__getPosition__useretval() {
   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 = 1;
   if (cond) { x=100; sf::Window::setPosition(arg1); }
@@ -1333,12 +943,6 @@ void test__sf__Window__setPosition__noreturn() {
   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
@@ -1352,12 +956,6 @@ void test__sf__RenderWindow__setPosition__noreturn() {
   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
@@ -1376,12 +974,6 @@ void test__sf__Window__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getSize(); }
@@ -1394,12 +986,6 @@ void test__sf__RenderWindow__getSize__useretval() {
   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 = 1;
   if (cond) { x=100; sf::Window::setSize(arg1); }
@@ -1407,12 +993,6 @@ void test__sf__Window__setSize__noreturn() {
   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
@@ -1426,12 +1006,6 @@ void test__sf__RenderWindow__setSize__noreturn() {
   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
@@ -1445,12 +1019,6 @@ void test__sf__Window__setTitle__noreturn() {
   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
@@ -1464,12 +1032,6 @@ void test__sf__RenderWindow__setTitle__noreturn() {
   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
@@ -1483,12 +1045,6 @@ void test__sf__Window__setIcon__noreturn() {
   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
@@ -1520,12 +1076,6 @@ void test__sf__RenderWindow__setIcon__noreturn() {
   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
@@ -1557,12 +1107,6 @@ void test__sf__Window__setVisible__noreturn() {
   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
@@ -1576,12 +1120,6 @@ void test__sf__Window__setVerticalSyncEnabled__noreturn() {
   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
@@ -1595,12 +1133,6 @@ void test__sf__Window__setMouseCursorVisible__noreturn() {
   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
@@ -1614,12 +1146,6 @@ void test__sf__Window__setMouseCursorGrabbed__noreturn() {
   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
@@ -1633,12 +1159,6 @@ void test__sf__Window__setKeyRepeatEnabled__noreturn() {
   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
@@ -1652,12 +1172,6 @@ void test__sf__RenderWindow__setVisible__noreturn() {
   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
@@ -1671,12 +1185,6 @@ void test__sf__RenderWindow__setVerticalSyncEnabled__noreturn() {
   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
@@ -1690,12 +1198,6 @@ void test__sf__RenderWindow__setMouseCursorVisible__noreturn() {
   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
@@ -1709,12 +1211,6 @@ void test__sf__RenderWindow__setMouseCursorGrabbed__noreturn() {
   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
@@ -1728,12 +1224,6 @@ void test__sf__RenderWindow__setKeyRepeatEnabled__noreturn() {
   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
@@ -1747,12 +1237,6 @@ void test__sf__Window__setFramerateLimit__noreturn() {
   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
@@ -1766,12 +1250,6 @@ void test__sf__RenderWindow__setFramerateLimit__noreturn() {
   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
@@ -1785,12 +1263,6 @@ void test__sf__Window__setJoystickThreshold__noreturn() {
   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
@@ -1804,12 +1276,6 @@ void test__sf__RenderWindow__setJoystickThreshold__noreturn() {
   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
@@ -1823,12 +1289,6 @@ void test__sf__Window__requestFocus__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::requestFocus(); }
@@ -1836,12 +1296,6 @@ void test__sf__RenderWindow__requestFocus__noreturn() {
   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 = 1;
   if (cond) { x=100; result = sf::Window::hasFocus(); }
@@ -1854,12 +1308,6 @@ void test__sf__Window__hasFocus__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::hasFocus(); }
@@ -1872,12 +1320,6 @@ void test__sf__RenderWindow__hasFocus__useretval() {
   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 = 1;
   if (cond) { x=100; sf::Window::display(); }
@@ -1885,12 +1327,6 @@ void test__sf__Window__display__noreturn() {
   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 = 1;
   if (cond) { x=100; sf::RenderWindow::display(); }
@@ -1898,12 +1334,6 @@ void test__sf__RenderWindow__display__noreturn() {
   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 = 1;
   if (cond) { x=100; result = sf::Window::getSystemHandle(); }
@@ -1916,12 +1346,6 @@ void test__sf__Window__getSystemHandle__useretval() {
   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 = 1;
   if (cond) { x=100; result = sf::RenderWindow::getSystemHandle(); }
@@ -1934,9 +1358,3 @@ void test__sf__RenderWindow__getSystemHandle__useretval() {
   sf::RenderWindow::getSystemHandle();
 }
 
-void test__sf__RenderWindow__getSystemHandle__leakignore() {
-  char *p = strdup(str);
-  result = sf::RenderWindow::getSystemHandle();
-  // cppcheck-suppress memleak
-}
-
diff --git a/test/cfg/generated-cfg-tests-std.cpp b/test/cfg/generated-cfg-tests-std.cpp
index 69f6bc682..e391a847a 100644
--- a/test/cfg/generated-cfg-tests-std.cpp
+++ b/test/cfg/generated-cfg-tests-std.cpp
@@ -40,7 +40,7 @@ void test__abs__pure(int arg1) {
 }
 
 void test__abs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = abs(p);
   // cppcheck-suppress memleak
 }
@@ -73,12 +73,6 @@ void test__std__abs__pure(int arg1) {
   if ((std::abs(arg1) > 10) || (std::abs(arg1) < 100)) {}
 }
 
-void test__std__abs__leakignore() {
-  char *p = strdup(str);
-  result = std::abs(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__abs__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   result = std::abs(!x);
@@ -108,7 +102,7 @@ void test__imaxabs__pure(int arg1) {
 }
 
 void test__imaxabs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = imaxabs(p);
   // cppcheck-suppress memleak
 }
@@ -136,12 +130,6 @@ void test__std__imaxabs__pure(int arg1) {
   if ((std::imaxabs(arg1) > 10) || (std::imaxabs(arg1) < 100)) {}
 }
 
-void test__std__imaxabs__leakignore() {
-  char *p = strdup(str);
-  result = std::imaxabs(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__imaxabs__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -165,12 +153,6 @@ void test__std__proj__pure(int arg1) {
   if ((std::proj(arg1) > 10) || (std::proj(arg1) < 100)) {}
 }
 
-void test__std__proj__leakignore() {
-  char *p = strdup(str);
-  result = std::proj(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__proj__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -195,7 +177,7 @@ void test__cproj__pure(int arg1) {
 }
 
 void test__cproj__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cproj(p);
   // cppcheck-suppress memleak
 }
@@ -224,7 +206,7 @@ void test__cprojf__pure(int arg1) {
 }
 
 void test__cprojf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cprojf(p);
   // cppcheck-suppress memleak
 }
@@ -253,7 +235,7 @@ void test__cprojl__pure(int arg1) {
 }
 
 void test__cprojl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cprojl(p);
   // cppcheck-suppress memleak
 }
@@ -282,7 +264,7 @@ void test__creal__pure(int arg1) {
 }
 
 void test__creal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = creal(p);
   // cppcheck-suppress memleak
 }
@@ -311,7 +293,7 @@ void test__crealf__pure(int arg1) {
 }
 
 void test__crealf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = crealf(p);
   // cppcheck-suppress memleak
 }
@@ -340,7 +322,7 @@ void test__creall__pure(int arg1) {
 }
 
 void test__creall__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = creall(p);
   // cppcheck-suppress memleak
 }
@@ -369,7 +351,7 @@ void test__acos__pure(int arg1) {
 }
 
 void test__acos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acos(p);
   // cppcheck-suppress memleak
 }
@@ -397,12 +379,6 @@ void test__std__acos__pure(int arg1) {
   if ((std::acos(arg1) > 10) || (std::acos(arg1) < 100)) {}
 }
 
-void test__std__acos__leakignore() {
-  char *p = strdup(str);
-  result = std::acos(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acos__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -427,7 +403,7 @@ void test__acosf__pure(int arg1) {
 }
 
 void test__acosf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acosf(p);
   // cppcheck-suppress memleak
 }
@@ -455,12 +431,6 @@ void test__std__acosf__pure(int arg1) {
   if ((std::acosf(arg1) > 10) || (std::acosf(arg1) < 100)) {}
 }
 
-void test__std__acosf__leakignore() {
-  char *p = strdup(str);
-  result = std::acosf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acosf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -485,7 +455,7 @@ void test__acosl__pure(int arg1) {
 }
 
 void test__acosl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acosl(p);
   // cppcheck-suppress memleak
 }
@@ -513,12 +483,6 @@ void test__std__acosl__pure(int arg1) {
   if ((std::acosl(arg1) > 10) || (std::acosl(arg1) < 100)) {}
 }
 
-void test__std__acosl__leakignore() {
-  char *p = strdup(str);
-  result = std::acosl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acosl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -543,7 +507,7 @@ void test__acosh__pure(int arg1) {
 }
 
 void test__acosh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acosh(p);
   // cppcheck-suppress memleak
 }
@@ -571,12 +535,6 @@ void test__std__acosh__pure(int arg1) {
   if ((std::acosh(arg1) > 10) || (std::acosh(arg1) < 100)) {}
 }
 
-void test__std__acosh__leakignore() {
-  char *p = strdup(str);
-  result = std::acosh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acosh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -601,7 +559,7 @@ void test__acoshf__pure(int arg1) {
 }
 
 void test__acoshf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acoshf(p);
   // cppcheck-suppress memleak
 }
@@ -629,12 +587,6 @@ void test__std__acoshf__pure(int arg1) {
   if ((std::acoshf(arg1) > 10) || (std::acoshf(arg1) < 100)) {}
 }
 
-void test__std__acoshf__leakignore() {
-  char *p = strdup(str);
-  result = std::acoshf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acoshf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -659,7 +611,7 @@ void test__acoshl__pure(int arg1) {
 }
 
 void test__acoshl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = acoshl(p);
   // cppcheck-suppress memleak
 }
@@ -687,12 +639,6 @@ void test__std__acoshl__pure(int arg1) {
   if ((std::acoshl(arg1) > 10) || (std::acoshl(arg1) < 100)) {}
 }
 
-void test__std__acoshl__leakignore() {
-  char *p = strdup(str);
-  result = std::acoshl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__acoshl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -712,7 +658,7 @@ void test__asctime__useretval() {
 }
 
 void test__asctime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asctime(p);
   // cppcheck-suppress memleak
 }
@@ -741,12 +687,6 @@ void test__std__asctime__useretval() {
   std::asctime(arg1);
 }
 
-void test__std__asctime__leakignore() {
-  char *p = strdup(str);
-  result = std::asctime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asctime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -760,7 +700,7 @@ void test__std__asctime__arg1__notuninit() {
 }
 
 void test__assert__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   assert(p);
   // cppcheck-suppress memleak
 }
@@ -789,7 +729,7 @@ void test__sqrt__pure(int arg1) {
 }
 
 void test__sqrt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sqrt(p);
   // cppcheck-suppress memleak
 }
@@ -817,12 +757,6 @@ void test__std__sqrt__pure(int arg1) {
   if ((std::sqrt(arg1) > 10) || (std::sqrt(arg1) < 100)) {}
 }
 
-void test__std__sqrt__leakignore() {
-  char *p = strdup(str);
-  result = std::sqrt(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sqrt__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -847,7 +781,7 @@ void test__sqrtf__pure(int arg1) {
 }
 
 void test__sqrtf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sqrtf(p);
   // cppcheck-suppress memleak
 }
@@ -875,12 +809,6 @@ void test__std__sqrtf__pure(int arg1) {
   if ((std::sqrtf(arg1) > 10) || (std::sqrtf(arg1) < 100)) {}
 }
 
-void test__std__sqrtf__leakignore() {
-  char *p = strdup(str);
-  result = std::sqrtf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sqrtf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -905,7 +833,7 @@ void test__sqrtl__pure(int arg1) {
 }
 
 void test__sqrtl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sqrtl(p);
   // cppcheck-suppress memleak
 }
@@ -933,12 +861,6 @@ void test__std__sqrtl__pure(int arg1) {
   if ((std::sqrtl(arg1) > 10) || (std::sqrtl(arg1) < 100)) {}
 }
 
-void test__std__sqrtl__leakignore() {
-  char *p = strdup(str);
-  result = std::sqrtl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sqrtl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -963,7 +885,7 @@ void test__csqrt__pure(int arg1) {
 }
 
 void test__csqrt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csqrt(p);
   // cppcheck-suppress memleak
 }
@@ -992,7 +914,7 @@ void test__csqrtf__pure(int arg1) {
 }
 
 void test__csqrtf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csqrtf(p);
   // cppcheck-suppress memleak
 }
@@ -1021,7 +943,7 @@ void test__csqrtl__pure(int arg1) {
 }
 
 void test__csqrtl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csqrtl(p);
   // cppcheck-suppress memleak
 }
@@ -1050,7 +972,7 @@ void test__sinh__pure(int arg1) {
 }
 
 void test__sinh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sinh(p);
   // cppcheck-suppress memleak
 }
@@ -1078,12 +1000,6 @@ void test__std__sinh__pure(int arg1) {
   if ((std::sinh(arg1) > 10) || (std::sinh(arg1) < 100)) {}
 }
 
-void test__std__sinh__leakignore() {
-  char *p = strdup(str);
-  result = std::sinh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sinh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1108,7 +1024,7 @@ void test__sinhf__pure(int arg1) {
 }
 
 void test__sinhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sinhf(p);
   // cppcheck-suppress memleak
 }
@@ -1136,12 +1052,6 @@ void test__std__sinhf__pure(int arg1) {
   if ((std::sinhf(arg1) > 10) || (std::sinhf(arg1) < 100)) {}
 }
 
-void test__std__sinhf__leakignore() {
-  char *p = strdup(str);
-  result = std::sinhf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sinhf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1166,7 +1076,7 @@ void test__sinhl__pure(int arg1) {
 }
 
 void test__sinhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sinhl(p);
   // cppcheck-suppress memleak
 }
@@ -1194,12 +1104,6 @@ void test__std__sinhl__pure(int arg1) {
   if ((std::sinhl(arg1) > 10) || (std::sinhl(arg1) < 100)) {}
 }
 
-void test__std__sinhl__leakignore() {
-  char *p = strdup(str);
-  result = std::sinhl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sinhl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1224,7 +1128,7 @@ void test__sin__pure(int arg1) {
 }
 
 void test__sin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sin(p);
   // cppcheck-suppress memleak
 }
@@ -1252,12 +1156,6 @@ void test__std__sin__pure(int arg1) {
   if ((std::sin(arg1) > 10) || (std::sin(arg1) < 100)) {}
 }
 
-void test__std__sin__leakignore() {
-  char *p = strdup(str);
-  result = std::sin(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sin__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1282,7 +1180,7 @@ void test__sinf__pure(int arg1) {
 }
 
 void test__sinf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sinf(p);
   // cppcheck-suppress memleak
 }
@@ -1310,12 +1208,6 @@ void test__std__sinf__pure(int arg1) {
   if ((std::sinf(arg1) > 10) || (std::sinf(arg1) < 100)) {}
 }
 
-void test__std__sinf__leakignore() {
-  char *p = strdup(str);
-  result = std::sinf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sinf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1340,7 +1232,7 @@ void test__sinl__pure(int arg1) {
 }
 
 void test__sinl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = sinl(p);
   // cppcheck-suppress memleak
 }
@@ -1368,12 +1260,6 @@ void test__std__sinl__pure(int arg1) {
   if ((std::sinl(arg1) > 10) || (std::sinl(arg1) < 100)) {}
 }
 
-void test__std__sinl__leakignore() {
-  char *p = strdup(str);
-  result = std::sinl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sinl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1398,7 +1284,7 @@ void test__csin__pure(int arg1) {
 }
 
 void test__csin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csin(p);
   // cppcheck-suppress memleak
 }
@@ -1427,7 +1313,7 @@ void test__csinf__pure(int arg1) {
 }
 
 void test__csinf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csinf(p);
   // cppcheck-suppress memleak
 }
@@ -1456,7 +1342,7 @@ void test__csinl__pure(int arg1) {
 }
 
 void test__csinl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csinl(p);
   // cppcheck-suppress memleak
 }
@@ -1485,7 +1371,7 @@ void test__csinh__pure(int arg1) {
 }
 
 void test__csinh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csinh(p);
   // cppcheck-suppress memleak
 }
@@ -1514,7 +1400,7 @@ void test__csinhf__pure(int arg1) {
 }
 
 void test__csinhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csinhf(p);
   // cppcheck-suppress memleak
 }
@@ -1543,7 +1429,7 @@ void test__csinhl__pure(int arg1) {
 }
 
 void test__csinhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = csinhl(p);
   // cppcheck-suppress memleak
 }
@@ -1572,7 +1458,7 @@ void test__asin__pure(int arg1) {
 }
 
 void test__asin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asin(p);
   // cppcheck-suppress memleak
 }
@@ -1600,12 +1486,6 @@ void test__std__asin__pure(int arg1) {
   if ((std::asin(arg1) > 10) || (std::asin(arg1) < 100)) {}
 }
 
-void test__std__asin__leakignore() {
-  char *p = strdup(str);
-  result = std::asin(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asin__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1630,7 +1510,7 @@ void test__asinf__pure(int arg1) {
 }
 
 void test__asinf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asinf(p);
   // cppcheck-suppress memleak
 }
@@ -1658,12 +1538,6 @@ void test__std__asinf__pure(int arg1) {
   if ((std::asinf(arg1) > 10) || (std::asinf(arg1) < 100)) {}
 }
 
-void test__std__asinf__leakignore() {
-  char *p = strdup(str);
-  result = std::asinf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asinf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1688,7 +1562,7 @@ void test__asinl__pure(int arg1) {
 }
 
 void test__asinl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asinl(p);
   // cppcheck-suppress memleak
 }
@@ -1716,12 +1590,6 @@ void test__std__asinl__pure(int arg1) {
   if ((std::asinl(arg1) > 10) || (std::asinl(arg1) < 100)) {}
 }
 
-void test__std__asinl__leakignore() {
-  char *p = strdup(str);
-  result = std::asinl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asinl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1746,7 +1614,7 @@ void test__casin__pure(int arg1) {
 }
 
 void test__casin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casin(p);
   // cppcheck-suppress memleak
 }
@@ -1775,7 +1643,7 @@ void test__casinf__pure(int arg1) {
 }
 
 void test__casinf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casinf(p);
   // cppcheck-suppress memleak
 }
@@ -1804,7 +1672,7 @@ void test__casinl__pure(int arg1) {
 }
 
 void test__casinl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casinl(p);
   // cppcheck-suppress memleak
 }
@@ -1833,7 +1701,7 @@ void test__asinh__pure(int arg1) {
 }
 
 void test__asinh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asinh(p);
   // cppcheck-suppress memleak
 }
@@ -1861,12 +1729,6 @@ void test__std__asinh__pure(int arg1) {
   if ((std::asinh(arg1) > 10) || (std::asinh(arg1) < 100)) {}
 }
 
-void test__std__asinh__leakignore() {
-  char *p = strdup(str);
-  result = std::asinh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asinh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1891,7 +1753,7 @@ void test__asinhf__pure(int arg1) {
 }
 
 void test__asinhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asinhf(p);
   // cppcheck-suppress memleak
 }
@@ -1919,12 +1781,6 @@ void test__std__asinhf__pure(int arg1) {
   if ((std::asinhf(arg1) > 10) || (std::asinhf(arg1) < 100)) {}
 }
 
-void test__std__asinhf__leakignore() {
-  char *p = strdup(str);
-  result = std::asinhf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asinhf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -1949,7 +1805,7 @@ void test__asinhl__pure(int arg1) {
 }
 
 void test__asinhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = asinhl(p);
   // cppcheck-suppress memleak
 }
@@ -1977,12 +1833,6 @@ void test__std__asinhl__pure(int arg1) {
   if ((std::asinhl(arg1) > 10) || (std::asinhl(arg1) < 100)) {}
 }
 
-void test__std__asinhl__leakignore() {
-  char *p = strdup(str);
-  result = std::asinhl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__asinhl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2007,7 +1857,7 @@ void test__casinh__pure(int arg1) {
 }
 
 void test__casinh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casinh(p);
   // cppcheck-suppress memleak
 }
@@ -2036,7 +1886,7 @@ void test__casinhf__pure(int arg1) {
 }
 
 void test__casinhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casinhf(p);
   // cppcheck-suppress memleak
 }
@@ -2065,7 +1915,7 @@ void test__casinhl__pure(int arg1) {
 }
 
 void test__casinhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = casinhl(p);
   // cppcheck-suppress memleak
 }
@@ -2089,7 +1939,7 @@ void test__wcsftime__pure(int arg1,int arg2,int arg3,int arg4) {
 }
 
 void test__wcsftime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsftime(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2142,12 +1992,6 @@ void test__std__wcsftime__pure(int arg1,int arg2,int arg3,int arg4) {
   if ((std::wcsftime(arg1, arg2, arg3, arg4) > 10) || (std::wcsftime(arg1, arg2, arg3, arg4) < 100)) {}
 }
 
-void test__std__wcsftime__leakignore() {
-  char *p = strdup(str);
-  std::wcsftime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsftime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2202,7 +2046,7 @@ void test__tan__pure(int arg1) {
 }
 
 void test__tan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tan(p);
   // cppcheck-suppress memleak
 }
@@ -2230,12 +2074,6 @@ void test__std__tan__pure(int arg1) {
   if ((std::tan(arg1) > 10) || (std::tan(arg1) < 100)) {}
 }
 
-void test__std__tan__leakignore() {
-  char *p = strdup(str);
-  result = std::tan(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tan__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2260,7 +2098,7 @@ void test__tanf__pure(int arg1) {
 }
 
 void test__tanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tanf(p);
   // cppcheck-suppress memleak
 }
@@ -2288,12 +2126,6 @@ void test__std__tanf__pure(int arg1) {
   if ((std::tanf(arg1) > 10) || (std::tanf(arg1) < 100)) {}
 }
 
-void test__std__tanf__leakignore() {
-  char *p = strdup(str);
-  result = std::tanf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2318,7 +2150,7 @@ void test__tanl__pure(int arg1) {
 }
 
 void test__tanl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tanl(p);
   // cppcheck-suppress memleak
 }
@@ -2346,12 +2178,6 @@ void test__std__tanl__pure(int arg1) {
   if ((std::tanl(arg1) > 10) || (std::tanl(arg1) < 100)) {}
 }
 
-void test__std__tanl__leakignore() {
-  char *p = strdup(str);
-  result = std::tanl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tanl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2376,7 +2202,7 @@ void test__ctan__pure(int arg1) {
 }
 
 void test__ctan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctan(p);
   // cppcheck-suppress memleak
 }
@@ -2405,7 +2231,7 @@ void test__ctanf__pure(int arg1) {
 }
 
 void test__ctanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctanf(p);
   // cppcheck-suppress memleak
 }
@@ -2434,7 +2260,7 @@ void test__ctanl__pure(int arg1) {
 }
 
 void test__ctanl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctanl(p);
   // cppcheck-suppress memleak
 }
@@ -2463,7 +2289,7 @@ void test__tanh__pure(int arg1) {
 }
 
 void test__tanh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tanh(p);
   // cppcheck-suppress memleak
 }
@@ -2491,12 +2317,6 @@ void test__std__tanh__pure(int arg1) {
   if ((std::tanh(arg1) > 10) || (std::tanh(arg1) < 100)) {}
 }
 
-void test__std__tanh__leakignore() {
-  char *p = strdup(str);
-  result = std::tanh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tanh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2521,7 +2341,7 @@ void test__tanhf__pure(int arg1) {
 }
 
 void test__tanhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tanhf(p);
   // cppcheck-suppress memleak
 }
@@ -2549,12 +2369,6 @@ void test__std__tanhf__pure(int arg1) {
   if ((std::tanhf(arg1) > 10) || (std::tanhf(arg1) < 100)) {}
 }
 
-void test__std__tanhf__leakignore() {
-  char *p = strdup(str);
-  result = std::tanhf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tanhf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2579,7 +2393,7 @@ void test__tanhl__pure(int arg1) {
 }
 
 void test__tanhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tanhl(p);
   // cppcheck-suppress memleak
 }
@@ -2607,12 +2421,6 @@ void test__std__tanhl__pure(int arg1) {
   if ((std::tanhl(arg1) > 10) || (std::tanhl(arg1) < 100)) {}
 }
 
-void test__std__tanhl__leakignore() {
-  char *p = strdup(str);
-  result = std::tanhl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tanhl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2637,7 +2445,7 @@ void test__ctanh__pure(int arg1) {
 }
 
 void test__ctanh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctanh(p);
   // cppcheck-suppress memleak
 }
@@ -2666,7 +2474,7 @@ void test__ctanhf__pure(int arg1) {
 }
 
 void test__ctanhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctanhf(p);
   // cppcheck-suppress memleak
 }
@@ -2695,7 +2503,7 @@ void test__ctanhl__pure(int arg1) {
 }
 
 void test__ctanhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctanhl(p);
   // cppcheck-suppress memleak
 }
@@ -2719,7 +2527,7 @@ void test__feclearexcept__pure(int arg1) {
 }
 
 void test__feclearexcept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   feclearexcept(p);
   // cppcheck-suppress memleak
 }
@@ -2742,12 +2550,6 @@ void test__std__feclearexcept__pure(int arg1) {
   if ((std::feclearexcept(arg1) > 10) || (std::feclearexcept(arg1) < 100)) {}
 }
 
-void test__std__feclearexcept__leakignore() {
-  char *p = strdup(str);
-  std::feclearexcept(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__feclearexcept__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2762,7 +2564,7 @@ void test__fegetenv__noreturn() {
 }
 
 void test__fegetenv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fegetenv(p);
   // cppcheck-suppress memleak
 }
@@ -2780,12 +2582,6 @@ void test__std__fegetenv__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fegetenv__leakignore() {
-  char *p = strdup(str);
-  std::fegetenv(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fegetenv__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2800,7 +2596,7 @@ void test__fegetexceptflag__noreturn() {
 }
 
 void test__fegetexceptflag__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fegetexceptflag(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2824,12 +2620,6 @@ void test__std__fegetexceptflag__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fegetexceptflag__leakignore() {
-  char *p = strdup(str);
-  std::fegetexceptflag(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fegetexceptflag__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2860,7 +2650,7 @@ void test__fegetround__pure() {
 }
 
 void test__fegetround__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fegetround();
   // cppcheck-suppress memleak
 }
@@ -2882,12 +2672,6 @@ void test__std__fegetround__pure() {
   if ((std::fegetround() > 10) || (std::fegetround() < 100)) {}
 }
 
-void test__std__fegetround__leakignore() {
-  char *p = strdup(str);
-  result = std::fegetround();
-  // cppcheck-suppress memleak
-}
-
 void test__feholdexcept__noreturn() {
   int x = 1;
   if (cond) { x=100; feholdexcept(arg1); }
@@ -2896,7 +2680,7 @@ void test__feholdexcept__noreturn() {
 }
 
 void test__feholdexcept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   feholdexcept(p);
   // cppcheck-suppress memleak
 }
@@ -2914,12 +2698,6 @@ void test__std__feholdexcept__noreturn() {
   x = 1 << x;
 }
 
-void test__std__feholdexcept__leakignore() {
-  char *p = strdup(str);
-  std::feholdexcept(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__feholdexcept__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2934,7 +2712,7 @@ void test__feraiseexcept__noreturn() {
 }
 
 void test__feraiseexcept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   feraiseexcept(p);
   // cppcheck-suppress memleak
 }
@@ -2952,12 +2730,6 @@ void test__std__feraiseexcept__noreturn() {
   x = 1 << x;
 }
 
-void test__std__feraiseexcept__leakignore() {
-  char *p = strdup(str);
-  std::feraiseexcept(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__feraiseexcept__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -2972,7 +2744,7 @@ void test__fesetenv__noreturn() {
 }
 
 void test__fesetenv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fesetenv(p);
   // cppcheck-suppress memleak
 }
@@ -2996,12 +2768,6 @@ void test__std__fesetenv__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fesetenv__leakignore() {
-  char *p = strdup(str);
-  std::fesetenv(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fesetenv__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -3022,7 +2788,7 @@ void test__fesetexceptflag__noreturn() {
 }
 
 void test__fesetexceptflag__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fesetexceptflag(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3052,12 +2818,6 @@ void test__std__fesetexceptflag__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fesetexceptflag__leakignore() {
-  char *p = strdup(str);
-  std::fesetexceptflag(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fesetexceptflag__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -3084,7 +2844,7 @@ void test__fesetround__noreturn() {
 }
 
 void test__fesetround__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fesetround(p);
   // cppcheck-suppress memleak
 }
@@ -3102,12 +2862,6 @@ void test__std__fesetround__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fesetround__leakignore() {
-  char *p = strdup(str);
-  std::fesetround(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fesetround__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3122,7 +2876,7 @@ void test__fetestexcept__noreturn() {
 }
 
 void test__fetestexcept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fetestexcept(p);
   // cppcheck-suppress memleak
 }
@@ -3140,12 +2894,6 @@ void test__std__fetestexcept__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fetestexcept__leakignore() {
-  char *p = strdup(str);
-  std::fetestexcept(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fetestexcept__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3160,7 +2908,7 @@ void test__feupdateenv__noreturn() {
 }
 
 void test__feupdateenv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   feupdateenv(p);
   // cppcheck-suppress memleak
 }
@@ -3184,12 +2932,6 @@ void test__std__feupdateenv__noreturn() {
   x = 1 << x;
 }
 
-void test__std__feupdateenv__leakignore() {
-  char *p = strdup(str);
-  std::feupdateenv(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__feupdateenv__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -3220,7 +2962,7 @@ void test__atan__pure(int arg1) {
 }
 
 void test__atan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atan(p);
   // cppcheck-suppress memleak
 }
@@ -3248,12 +2990,6 @@ void test__std__atan__pure(int arg1) {
   if ((std::atan(arg1) > 10) || (std::atan(arg1) < 100)) {}
 }
 
-void test__std__atan__leakignore() {
-  char *p = strdup(str);
-  result = std::atan(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atan__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3278,7 +3014,7 @@ void test__atanf__pure(int arg1) {
 }
 
 void test__atanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atanf(p);
   // cppcheck-suppress memleak
 }
@@ -3306,12 +3042,6 @@ void test__std__atanf__pure(int arg1) {
   if ((std::atanf(arg1) > 10) || (std::atanf(arg1) < 100)) {}
 }
 
-void test__std__atanf__leakignore() {
-  char *p = strdup(str);
-  result = std::atanf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3336,7 +3066,7 @@ void test__atanl__pure(int arg1) {
 }
 
 void test__atanl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atanl(p);
   // cppcheck-suppress memleak
 }
@@ -3364,12 +3094,6 @@ void test__std__atanl__pure(int arg1) {
   if ((std::atanl(arg1) > 10) || (std::atanl(arg1) < 100)) {}
 }
 
-void test__std__atanl__leakignore() {
-  char *p = strdup(str);
-  result = std::atanl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atanl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3394,7 +3118,7 @@ void test__catan__pure(int arg1) {
 }
 
 void test__catan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catan(p);
   // cppcheck-suppress memleak
 }
@@ -3423,7 +3147,7 @@ void test__catanf__pure(int arg1) {
 }
 
 void test__catanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catanf(p);
   // cppcheck-suppress memleak
 }
@@ -3452,7 +3176,7 @@ void test__catanl__pure(int arg1) {
 }
 
 void test__catanl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catanl(p);
   // cppcheck-suppress memleak
 }
@@ -3481,7 +3205,7 @@ void test__tgamma__pure(int arg1) {
 }
 
 void test__tgamma__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tgamma(p);
   // cppcheck-suppress memleak
 }
@@ -3509,12 +3233,6 @@ void test__std__tgamma__pure(int arg1) {
   if ((std::tgamma(arg1) > 10) || (std::tgamma(arg1) < 100)) {}
 }
 
-void test__std__tgamma__leakignore() {
-  char *p = strdup(str);
-  result = std::tgamma(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tgamma__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3539,7 +3257,7 @@ void test__tgammaf__pure(int arg1) {
 }
 
 void test__tgammaf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tgammaf(p);
   // cppcheck-suppress memleak
 }
@@ -3567,12 +3285,6 @@ void test__std__tgammaf__pure(int arg1) {
   if ((std::tgammaf(arg1) > 10) || (std::tgammaf(arg1) < 100)) {}
 }
 
-void test__std__tgammaf__leakignore() {
-  char *p = strdup(str);
-  result = std::tgammaf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tgammaf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3597,7 +3309,7 @@ void test__tgammal__pure(int arg1) {
 }
 
 void test__tgammal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tgammal(p);
   // cppcheck-suppress memleak
 }
@@ -3625,12 +3337,6 @@ void test__std__tgammal__pure(int arg1) {
   if ((std::tgammal(arg1) > 10) || (std::tgammal(arg1) < 100)) {}
 }
 
-void test__std__tgammal__leakignore() {
-  char *p = strdup(str);
-  result = std::tgammal(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tgammal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3655,7 +3361,7 @@ void test__trunc__pure(int arg1) {
 }
 
 void test__trunc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = trunc(p);
   // cppcheck-suppress memleak
 }
@@ -3683,12 +3389,6 @@ void test__std__trunc__pure(int arg1) {
   if ((std::trunc(arg1) > 10) || (std::trunc(arg1) < 100)) {}
 }
 
-void test__std__trunc__leakignore() {
-  char *p = strdup(str);
-  result = std::trunc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__trunc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3713,7 +3413,7 @@ void test__truncf__pure(int arg1) {
 }
 
 void test__truncf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = truncf(p);
   // cppcheck-suppress memleak
 }
@@ -3741,12 +3441,6 @@ void test__std__truncf__pure(int arg1) {
   if ((std::truncf(arg1) > 10) || (std::truncf(arg1) < 100)) {}
 }
 
-void test__std__truncf__leakignore() {
-  char *p = strdup(str);
-  result = std::truncf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__truncf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3771,7 +3465,7 @@ void test__truncl__pure(int arg1) {
 }
 
 void test__truncl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = truncl(p);
   // cppcheck-suppress memleak
 }
@@ -3799,12 +3493,6 @@ void test__std__truncl__pure(int arg1) {
   if ((std::truncl(arg1) > 10) || (std::truncl(arg1) < 100)) {}
 }
 
-void test__std__truncl__leakignore() {
-  char *p = strdup(str);
-  result = std::truncl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__truncl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3829,7 +3517,7 @@ void test__atanh__pure(int arg1) {
 }
 
 void test__atanh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atanh(p);
   // cppcheck-suppress memleak
 }
@@ -3857,12 +3545,6 @@ void test__std__atanh__pure(int arg1) {
   if ((std::atanh(arg1) > 10) || (std::atanh(arg1) < 100)) {}
 }
 
-void test__std__atanh__leakignore() {
-  char *p = strdup(str);
-  result = std::atanh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atanh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3887,7 +3569,7 @@ void test__atanhf__pure(int arg1) {
 }
 
 void test__atanhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atanhf(p);
   // cppcheck-suppress memleak
 }
@@ -3915,12 +3597,6 @@ void test__std__atanhf__pure(int arg1) {
   if ((std::atanhf(arg1) > 10) || (std::atanhf(arg1) < 100)) {}
 }
 
-void test__std__atanhf__leakignore() {
-  char *p = strdup(str);
-  result = std::atanhf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atanhf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -3945,7 +3621,7 @@ void test__atanhl__pure(int arg1) {
 }
 
 void test__atanhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atanhl(p);
   // cppcheck-suppress memleak
 }
@@ -3973,12 +3649,6 @@ void test__std__atanhl__pure(int arg1) {
   if ((std::atanhl(arg1) > 10) || (std::atanhl(arg1) < 100)) {}
 }
 
-void test__std__atanhl__leakignore() {
-  char *p = strdup(str);
-  result = std::atanhl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atanhl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4003,7 +3673,7 @@ void test__catanh__pure(int arg1) {
 }
 
 void test__catanh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catanh(p);
   // cppcheck-suppress memleak
 }
@@ -4032,7 +3702,7 @@ void test__catanhf__pure(int arg1) {
 }
 
 void test__catanhf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catanhf(p);
   // cppcheck-suppress memleak
 }
@@ -4061,7 +3731,7 @@ void test__catanhl__pure(int arg1) {
 }
 
 void test__catanhl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = catanhl(p);
   // cppcheck-suppress memleak
 }
@@ -4090,7 +3760,7 @@ void test__atan2__pure(int arg1,int arg2) {
 }
 
 void test__atan2__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atan2(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4124,12 +3794,6 @@ void test__std__atan2__pure(int arg1,int arg2) {
   if ((std::atan2(arg1, arg2) > 10) || (std::atan2(arg1, arg2) < 100)) {}
 }
 
-void test__std__atan2__leakignore() {
-  char *p = strdup(str);
-  result = std::atan2(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atan2__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4160,7 +3824,7 @@ void test__atan2f__pure(int arg1,int arg2) {
 }
 
 void test__atan2f__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atan2f(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4194,12 +3858,6 @@ void test__std__atan2f__pure(int arg1,int arg2) {
   if ((std::atan2f(arg1, arg2) > 10) || (std::atan2f(arg1, arg2) < 100)) {}
 }
 
-void test__std__atan2f__leakignore() {
-  char *p = strdup(str);
-  result = std::atan2f(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atan2f__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4230,7 +3888,7 @@ void test__atan2l__pure(int arg1,int arg2) {
 }
 
 void test__atan2l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atan2l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4264,12 +3922,6 @@ void test__std__atan2l__pure(int arg1,int arg2) {
   if ((std::atan2l(arg1, arg2) > 10) || (std::atan2l(arg1, arg2) < 100)) {}
 }
 
-void test__std__atan2l__leakignore() {
-  char *p = strdup(str);
-  result = std::atan2l(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atan2l__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4295,7 +3947,7 @@ void test__atexit__pure(int arg1) {
 }
 
 void test__atexit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   atexit(p);
   // cppcheck-suppress memleak
 }
@@ -4318,12 +3970,6 @@ void test__std__atexit__pure(int arg1) {
   if ((std::atexit(arg1) > 10) || (std::atexit(arg1) < 100)) {}
 }
 
-void test__std__atexit__leakignore() {
-  char *p = strdup(str);
-  std::atexit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atexit__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4348,7 +3994,7 @@ void test__atoi__pure(int arg1) {
 }
 
 void test__atoi__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atoi(p);
   // cppcheck-suppress memleak
 }
@@ -4382,12 +4028,6 @@ void test__std__atoi__pure(int arg1) {
   if ((std::atoi(arg1) > 10) || (std::atoi(arg1) < 100)) {}
 }
 
-void test__std__atoi__leakignore() {
-  char *p = strdup(str);
-  result = std::atoi(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atoi__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4418,7 +4058,7 @@ void test__atol__pure(int arg1) {
 }
 
 void test__atol__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atol(p);
   // cppcheck-suppress memleak
 }
@@ -4452,12 +4092,6 @@ void test__std__atol__pure(int arg1) {
   if ((std::atol(arg1) > 10) || (std::atol(arg1) < 100)) {}
 }
 
-void test__std__atol__leakignore() {
-  char *p = strdup(str);
-  result = std::atol(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atol__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4488,7 +4122,7 @@ void test__atoll__pure(int arg1) {
 }
 
 void test__atoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atoll(p);
   // cppcheck-suppress memleak
 }
@@ -4522,12 +4156,6 @@ void test__std__atoll__pure(int arg1) {
   if ((std::atoll(arg1) > 10) || (std::atoll(arg1) < 100)) {}
 }
 
-void test__std__atoll__leakignore() {
-  char *p = strdup(str);
-  result = std::atoll(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atoll__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4558,7 +4186,7 @@ void test__atof__pure(int arg1) {
 }
 
 void test__atof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = atof(p);
   // cppcheck-suppress memleak
 }
@@ -4592,12 +4220,6 @@ void test__std__atof__pure(int arg1) {
   if ((std::atof(arg1) > 10) || (std::atof(arg1) < 100)) {}
 }
 
-void test__std__atof__leakignore() {
-  char *p = strdup(str);
-  result = std::atof(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__atof__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -4652,7 +4274,7 @@ void test__ceil__pure(int arg1) {
 }
 
 void test__ceil__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ceil(p);
   // cppcheck-suppress memleak
 }
@@ -4680,12 +4302,6 @@ void test__std__ceil__pure(int arg1) {
   if ((std::ceil(arg1) > 10) || (std::ceil(arg1) < 100)) {}
 }
 
-void test__std__ceil__leakignore() {
-  char *p = strdup(str);
-  result = std::ceil(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ceil__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4710,7 +4326,7 @@ void test__ceilf__pure(int arg1) {
 }
 
 void test__ceilf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ceilf(p);
   // cppcheck-suppress memleak
 }
@@ -4738,12 +4354,6 @@ void test__std__ceilf__pure(int arg1) {
   if ((std::ceilf(arg1) > 10) || (std::ceilf(arg1) < 100)) {}
 }
 
-void test__std__ceilf__leakignore() {
-  char *p = strdup(str);
-  result = std::ceilf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ceilf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4768,7 +4378,7 @@ void test__ceill__pure(int arg1) {
 }
 
 void test__ceill__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ceill(p);
   // cppcheck-suppress memleak
 }
@@ -4796,12 +4406,6 @@ void test__std__ceill__pure(int arg1) {
   if ((std::ceill(arg1) > 10) || (std::ceill(arg1) < 100)) {}
 }
 
-void test__std__ceill__leakignore() {
-  char *p = strdup(str);
-  result = std::ceill(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ceill__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4826,7 +4430,7 @@ void test__copysign__pure(int arg1,int arg2) {
 }
 
 void test__copysign__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = copysign(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4860,12 +4464,6 @@ void test__std__copysign__pure(int arg1,int arg2) {
   if ((std::copysign(arg1, arg2) > 10) || (std::copysign(arg1, arg2) < 100)) {}
 }
 
-void test__std__copysign__leakignore() {
-  char *p = strdup(str);
-  result = std::copysign(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__copysign__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4896,7 +4494,7 @@ void test__copysignf__pure(int arg1,int arg2) {
 }
 
 void test__copysignf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = copysignf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4930,12 +4528,6 @@ void test__std__copysignf__pure(int arg1,int arg2) {
   if ((std::copysignf(arg1, arg2) > 10) || (std::copysignf(arg1, arg2) < 100)) {}
 }
 
-void test__std__copysignf__leakignore() {
-  char *p = strdup(str);
-  result = std::copysignf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__copysignf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -4966,7 +4558,7 @@ void test__copysignl__pure(int arg1,int arg2) {
 }
 
 void test__copysignl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = copysignl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5000,12 +4592,6 @@ void test__std__copysignl__pure(int arg1,int arg2) {
   if ((std::copysignl(arg1, arg2) > 10) || (std::copysignl(arg1, arg2) < 100)) {}
 }
 
-void test__std__copysignl__leakignore() {
-  char *p = strdup(str);
-  result = std::copysignl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__copysignl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5026,7 +4612,7 @@ void test__clearerr__noreturn() {
 }
 
 void test__clearerr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   clearerr(p);
   // cppcheck-suppress memleak
 }
@@ -5050,12 +4636,6 @@ void test__std__clearerr__noreturn() {
   x = 1 << x;
 }
 
-void test__std__clearerr__leakignore() {
-  char *p = strdup(str);
-  std::clearerr(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__clearerr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -5081,7 +4661,7 @@ void test__clock__useretval() {
 }
 
 void test__clock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = clock();
   // cppcheck-suppress memleak
 }
@@ -5104,7 +4684,7 @@ void test__cbrt__pure(int arg1) {
 }
 
 void test__cbrt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cbrt(p);
   // cppcheck-suppress memleak
 }
@@ -5132,12 +4712,6 @@ void test__std__cbrt__pure(int arg1) {
   if ((std::cbrt(arg1) > 10) || (std::cbrt(arg1) < 100)) {}
 }
 
-void test__std__cbrt__leakignore() {
-  char *p = strdup(str);
-  result = std::cbrt(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cbrt__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5162,7 +4736,7 @@ void test__cbrtf__pure(int arg1) {
 }
 
 void test__cbrtf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cbrtf(p);
   // cppcheck-suppress memleak
 }
@@ -5190,12 +4764,6 @@ void test__std__cbrtf__pure(int arg1) {
   if ((std::cbrtf(arg1) > 10) || (std::cbrtf(arg1) < 100)) {}
 }
 
-void test__std__cbrtf__leakignore() {
-  char *p = strdup(str);
-  result = std::cbrtf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cbrtf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5220,7 +4788,7 @@ void test__cbrtl__pure(int arg1) {
 }
 
 void test__cbrtl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cbrtl(p);
   // cppcheck-suppress memleak
 }
@@ -5248,12 +4816,6 @@ void test__std__cbrtl__pure(int arg1) {
   if ((std::cbrtl(arg1) > 10) || (std::cbrtl(arg1) < 100)) {}
 }
 
-void test__std__cbrtl__leakignore() {
-  char *p = strdup(str);
-  result = std::cbrtl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cbrtl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5278,7 +4840,7 @@ void test__cos__pure(int arg1) {
 }
 
 void test__cos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cos(p);
   // cppcheck-suppress memleak
 }
@@ -5306,12 +4868,6 @@ void test__std__cos__pure(int arg1) {
   if ((std::cos(arg1) > 10) || (std::cos(arg1) < 100)) {}
 }
 
-void test__std__cos__leakignore() {
-  char *p = strdup(str);
-  result = std::cos(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cos__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5336,7 +4892,7 @@ void test__cosf__pure(int arg1) {
 }
 
 void test__cosf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cosf(p);
   // cppcheck-suppress memleak
 }
@@ -5364,12 +4920,6 @@ void test__std__cosf__pure(int arg1) {
   if ((std::cosf(arg1) > 10) || (std::cosf(arg1) < 100)) {}
 }
 
-void test__std__cosf__leakignore() {
-  char *p = strdup(str);
-  result = std::cosf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cosf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5394,7 +4944,7 @@ void test__cosl__pure(int arg1) {
 }
 
 void test__cosl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cosl(p);
   // cppcheck-suppress memleak
 }
@@ -5422,12 +4972,6 @@ void test__std__cosl__pure(int arg1) {
   if ((std::cosl(arg1) > 10) || (std::cosl(arg1) < 100)) {}
 }
 
-void test__std__cosl__leakignore() {
-  char *p = strdup(str);
-  result = std::cosl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cosl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5452,7 +4996,7 @@ void test__ccos__pure(int arg1) {
 }
 
 void test__ccos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccos(p);
   // cppcheck-suppress memleak
 }
@@ -5481,7 +5025,7 @@ void test__ccosf__pure(int arg1) {
 }
 
 void test__ccosf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccosf(p);
   // cppcheck-suppress memleak
 }
@@ -5510,7 +5054,7 @@ void test__ccosl__pure(int arg1) {
 }
 
 void test__ccosl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccosl(p);
   // cppcheck-suppress memleak
 }
@@ -5539,7 +5083,7 @@ void test__cosh__pure(int arg1) {
 }
 
 void test__cosh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cosh(p);
   // cppcheck-suppress memleak
 }
@@ -5567,12 +5111,6 @@ void test__std__cosh__pure(int arg1) {
   if ((std::cosh(arg1) > 10) || (std::cosh(arg1) < 100)) {}
 }
 
-void test__std__cosh__leakignore() {
-  char *p = strdup(str);
-  result = std::cosh(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__cosh__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5597,7 +5135,7 @@ void test__coshf__pure(int arg1) {
 }
 
 void test__coshf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = coshf(p);
   // cppcheck-suppress memleak
 }
@@ -5625,12 +5163,6 @@ void test__std__coshf__pure(int arg1) {
   if ((std::coshf(arg1) > 10) || (std::coshf(arg1) < 100)) {}
 }
 
-void test__std__coshf__leakignore() {
-  char *p = strdup(str);
-  result = std::coshf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__coshf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5655,7 +5187,7 @@ void test__coshl__pure(int arg1) {
 }
 
 void test__coshl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = coshl(p);
   // cppcheck-suppress memleak
 }
@@ -5683,12 +5215,6 @@ void test__std__coshl__pure(int arg1) {
   if ((std::coshl(arg1) > 10) || (std::coshl(arg1) < 100)) {}
 }
 
-void test__std__coshl__leakignore() {
-  char *p = strdup(str);
-  result = std::coshl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__coshl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5713,7 +5239,7 @@ void test__ccosh__pure(int arg1) {
 }
 
 void test__ccosh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccosh(p);
   // cppcheck-suppress memleak
 }
@@ -5742,7 +5268,7 @@ void test__ccoshf__pure(int arg1) {
 }
 
 void test__ccoshf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccoshf(p);
   // cppcheck-suppress memleak
 }
@@ -5771,7 +5297,7 @@ void test__ccoshl__pure(int arg1) {
 }
 
 void test__ccoshl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ccoshl(p);
   // cppcheck-suppress memleak
 }
@@ -5795,7 +5321,7 @@ void test__ctime__useretval() {
 }
 
 void test__ctime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ctime(p);
   // cppcheck-suppress memleak
 }
@@ -5824,12 +5350,6 @@ void test__std__ctime__useretval() {
   std::ctime(arg1);
 }
 
-void test__std__ctime__leakignore() {
-  char *p = strdup(str);
-  result = std::ctime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ctime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -5855,7 +5375,7 @@ void test__difftime__useretval() {
 }
 
 void test__difftime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = difftime(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5884,12 +5404,6 @@ void test__std__difftime__useretval() {
   std::difftime(arg1, arg2);
 }
 
-void test__std__difftime__leakignore() {
-  char *p = strdup(str);
-  result = std::difftime(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__difftime__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5915,7 +5429,7 @@ void test__div__pure(int arg1,int arg2) {
 }
 
 void test__div__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   div(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -5944,12 +5458,6 @@ void test__std__div__pure(int arg1,int arg2) {
   if ((std::div(arg1, arg2) > 10) || (std::div(arg1, arg2) < 100)) {}
 }
 
-void test__std__div__leakignore() {
-  char *p = strdup(str);
-  std::div(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__div__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -5975,7 +5483,7 @@ void test__imaxdiv__pure(int arg1,int arg2) {
 }
 
 void test__imaxdiv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   imaxdiv(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6004,12 +5512,6 @@ void test__std__imaxdiv__pure(int arg1,int arg2) {
   if ((std::imaxdiv(arg1, arg2) > 10) || (std::imaxdiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__imaxdiv__leakignore() {
-  char *p = strdup(str);
-  std::imaxdiv(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__imaxdiv__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6066,7 +5568,7 @@ void test__erf__pure(int arg1) {
 }
 
 void test__erf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erf(p);
   // cppcheck-suppress memleak
 }
@@ -6094,12 +5596,6 @@ void test__std__erf__pure(int arg1) {
   if ((std::erf(arg1) > 10) || (std::erf(arg1) < 100)) {}
 }
 
-void test__std__erf__leakignore() {
-  char *p = strdup(str);
-  result = std::erf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6124,7 +5620,7 @@ void test__erff__pure(int arg1) {
 }
 
 void test__erff__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erff(p);
   // cppcheck-suppress memleak
 }
@@ -6152,12 +5648,6 @@ void test__std__erff__pure(int arg1) {
   if ((std::erff(arg1) > 10) || (std::erff(arg1) < 100)) {}
 }
 
-void test__std__erff__leakignore() {
-  char *p = strdup(str);
-  result = std::erff(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erff__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6182,7 +5672,7 @@ void test__erfl__pure(int arg1) {
 }
 
 void test__erfl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erfl(p);
   // cppcheck-suppress memleak
 }
@@ -6210,12 +5700,6 @@ void test__std__erfl__pure(int arg1) {
   if ((std::erfl(arg1) > 10) || (std::erfl(arg1) < 100)) {}
 }
 
-void test__std__erfl__leakignore() {
-  char *p = strdup(str);
-  result = std::erfl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erfl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6240,7 +5724,7 @@ void test__erfc__pure(int arg1) {
 }
 
 void test__erfc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erfc(p);
   // cppcheck-suppress memleak
 }
@@ -6268,12 +5752,6 @@ void test__std__erfc__pure(int arg1) {
   if ((std::erfc(arg1) > 10) || (std::erfc(arg1) < 100)) {}
 }
 
-void test__std__erfc__leakignore() {
-  char *p = strdup(str);
-  result = std::erfc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erfc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6298,7 +5776,7 @@ void test__erfcf__pure(int arg1) {
 }
 
 void test__erfcf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erfcf(p);
   // cppcheck-suppress memleak
 }
@@ -6326,12 +5804,6 @@ void test__std__erfcf__pure(int arg1) {
   if ((std::erfcf(arg1) > 10) || (std::erfcf(arg1) < 100)) {}
 }
 
-void test__std__erfcf__leakignore() {
-  char *p = strdup(str);
-  result = std::erfcf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erfcf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6356,7 +5828,7 @@ void test__erfcl__pure(int arg1) {
 }
 
 void test__erfcl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = erfcl(p);
   // cppcheck-suppress memleak
 }
@@ -6384,12 +5856,6 @@ void test__std__erfcl__pure(int arg1) {
   if ((std::erfcl(arg1) > 10) || (std::erfcl(arg1) < 100)) {}
 }
 
-void test__std__erfcl__leakignore() {
-  char *p = strdup(str);
-  result = std::erfcl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__erfcl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6414,7 +5880,7 @@ void test__carg__pure(int arg1) {
 }
 
 void test__carg__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = carg(p);
   // cppcheck-suppress memleak
 }
@@ -6443,7 +5909,7 @@ void test__cargf__pure(int arg1) {
 }
 
 void test__cargf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cargf(p);
   // cppcheck-suppress memleak
 }
@@ -6472,7 +5938,7 @@ void test__cargl__pure(int arg1) {
 }
 
 void test__cargl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cargl(p);
   // cppcheck-suppress memleak
 }
@@ -6501,7 +5967,7 @@ void test__exp__pure(int arg1) {
 }
 
 void test__exp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = exp(p);
   // cppcheck-suppress memleak
 }
@@ -6529,12 +5995,6 @@ void test__std__exp__pure(int arg1) {
   if ((std::exp(arg1) > 10) || (std::exp(arg1) < 100)) {}
 }
 
-void test__std__exp__leakignore() {
-  char *p = strdup(str);
-  result = std::exp(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__exp__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6559,7 +6019,7 @@ void test__expf__pure(int arg1) {
 }
 
 void test__expf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = expf(p);
   // cppcheck-suppress memleak
 }
@@ -6587,12 +6047,6 @@ void test__std__expf__pure(int arg1) {
   if ((std::expf(arg1) > 10) || (std::expf(arg1) < 100)) {}
 }
 
-void test__std__expf__leakignore() {
-  char *p = strdup(str);
-  result = std::expf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__expf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6617,7 +6071,7 @@ void test__expl__pure(int arg1) {
 }
 
 void test__expl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = expl(p);
   // cppcheck-suppress memleak
 }
@@ -6645,12 +6099,6 @@ void test__std__expl__pure(int arg1) {
   if ((std::expl(arg1) > 10) || (std::expl(arg1) < 100)) {}
 }
 
-void test__std__expl__leakignore() {
-  char *p = strdup(str);
-  result = std::expl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__expl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6675,7 +6123,7 @@ void test__cexp__pure(int arg1) {
 }
 
 void test__cexp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cexp(p);
   // cppcheck-suppress memleak
 }
@@ -6704,7 +6152,7 @@ void test__cexpf__pure(int arg1) {
 }
 
 void test__cexpf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cexpf(p);
   // cppcheck-suppress memleak
 }
@@ -6733,7 +6181,7 @@ void test__cexpl__pure(int arg1) {
 }
 
 void test__cexpl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cexpl(p);
   // cppcheck-suppress memleak
 }
@@ -6762,7 +6210,7 @@ void test__cimag__pure(int arg1) {
 }
 
 void test__cimag__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cimag(p);
   // cppcheck-suppress memleak
 }
@@ -6791,7 +6239,7 @@ void test__cimagf__pure(int arg1) {
 }
 
 void test__cimagf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cimagf(p);
   // cppcheck-suppress memleak
 }
@@ -6820,7 +6268,7 @@ void test__cimagl__pure(int arg1) {
 }
 
 void test__cimagl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cimagl(p);
   // cppcheck-suppress memleak
 }
@@ -6849,7 +6297,7 @@ void test__exp2__pure(int arg1) {
 }
 
 void test__exp2__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = exp2(p);
   // cppcheck-suppress memleak
 }
@@ -6877,12 +6325,6 @@ void test__std__exp2__pure(int arg1) {
   if ((std::exp2(arg1) > 10) || (std::exp2(arg1) < 100)) {}
 }
 
-void test__std__exp2__leakignore() {
-  char *p = strdup(str);
-  result = std::exp2(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__exp2__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6907,7 +6349,7 @@ void test__exp2f__pure(int arg1) {
 }
 
 void test__exp2f__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = exp2f(p);
   // cppcheck-suppress memleak
 }
@@ -6935,12 +6377,6 @@ void test__std__exp2f__pure(int arg1) {
   if ((std::exp2f(arg1) > 10) || (std::exp2f(arg1) < 100)) {}
 }
 
-void test__std__exp2f__leakignore() {
-  char *p = strdup(str);
-  result = std::exp2f(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__exp2f__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -6965,7 +6401,7 @@ void test__exp2l__pure(int arg1) {
 }
 
 void test__exp2l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = exp2l(p);
   // cppcheck-suppress memleak
 }
@@ -6993,12 +6429,6 @@ void test__std__exp2l__pure(int arg1) {
   if ((std::exp2l(arg1) > 10) || (std::exp2l(arg1) < 100)) {}
 }
 
-void test__std__exp2l__leakignore() {
-  char *p = strdup(str);
-  result = std::exp2l(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__exp2l__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7023,7 +6453,7 @@ void test__expm1__pure(int arg1) {
 }
 
 void test__expm1__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = expm1(p);
   // cppcheck-suppress memleak
 }
@@ -7051,12 +6481,6 @@ void test__std__expm1__pure(int arg1) {
   if ((std::expm1(arg1) > 10) || (std::expm1(arg1) < 100)) {}
 }
 
-void test__std__expm1__leakignore() {
-  char *p = strdup(str);
-  result = std::expm1(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__expm1__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7081,7 +6505,7 @@ void test__expm1f__pure(int arg1) {
 }
 
 void test__expm1f__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = expm1f(p);
   // cppcheck-suppress memleak
 }
@@ -7109,12 +6533,6 @@ void test__std__expm1f__pure(int arg1) {
   if ((std::expm1f(arg1) > 10) || (std::expm1f(arg1) < 100)) {}
 }
 
-void test__std__expm1f__leakignore() {
-  char *p = strdup(str);
-  result = std::expm1f(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__expm1f__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7139,7 +6557,7 @@ void test__expm1l__pure(int arg1) {
 }
 
 void test__expm1l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = expm1l(p);
   // cppcheck-suppress memleak
 }
@@ -7167,12 +6585,6 @@ void test__std__expm1l__pure(int arg1) {
   if ((std::expm1l(arg1) > 10) || (std::expm1l(arg1) < 100)) {}
 }
 
-void test__std__expm1l__leakignore() {
-  char *p = strdup(str);
-  result = std::expm1l(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__expm1l__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7223,7 +6635,7 @@ void test__fabs__pure(int arg1) {
 }
 
 void test__fabs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fabs(p);
   // cppcheck-suppress memleak
 }
@@ -7251,12 +6663,6 @@ void test__std__fabs__pure(int arg1) {
   if ((std::fabs(arg1) > 10) || (std::fabs(arg1) < 100)) {}
 }
 
-void test__std__fabs__leakignore() {
-  char *p = strdup(str);
-  result = std::fabs(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fabs__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7281,7 +6687,7 @@ void test__fabsf__pure(int arg1) {
 }
 
 void test__fabsf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fabsf(p);
   // cppcheck-suppress memleak
 }
@@ -7309,12 +6715,6 @@ void test__std__fabsf__pure(int arg1) {
   if ((std::fabsf(arg1) > 10) || (std::fabsf(arg1) < 100)) {}
 }
 
-void test__std__fabsf__leakignore() {
-  char *p = strdup(str);
-  result = std::fabsf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fabsf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7339,7 +6739,7 @@ void test__fabsl__pure(int arg1) {
 }
 
 void test__fabsl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fabsl(p);
   // cppcheck-suppress memleak
 }
@@ -7367,12 +6767,6 @@ void test__std__fabsl__pure(int arg1) {
   if ((std::fabsl(arg1) > 10) || (std::fabsl(arg1) < 100)) {}
 }
 
-void test__std__fabsl__leakignore() {
-  char *p = strdup(str);
-  result = std::fabsl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fabsl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7397,7 +6791,7 @@ void test__fdim__pure(int arg1,int arg2) {
 }
 
 void test__fdim__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fdim(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7431,12 +6825,6 @@ void test__std__fdim__pure(int arg1,int arg2) {
   if ((std::fdim(arg1, arg2) > 10) || (std::fdim(arg1, arg2) < 100)) {}
 }
 
-void test__std__fdim__leakignore() {
-  char *p = strdup(str);
-  result = std::fdim(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fdim__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7467,7 +6855,7 @@ void test__fdimf__pure(int arg1,int arg2) {
 }
 
 void test__fdimf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fdimf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7501,12 +6889,6 @@ void test__std__fdimf__pure(int arg1,int arg2) {
   if ((std::fdimf(arg1, arg2) > 10) || (std::fdimf(arg1, arg2) < 100)) {}
 }
 
-void test__std__fdimf__leakignore() {
-  char *p = strdup(str);
-  result = std::fdimf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fdimf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7537,7 +6919,7 @@ void test__fdiml__pure(int arg1,int arg2) {
 }
 
 void test__fdiml__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fdiml(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7571,12 +6953,6 @@ void test__std__fdiml__pure(int arg1,int arg2) {
   if ((std::fdiml(arg1, arg2) > 10) || (std::fdiml(arg1, arg2) < 100)) {}
 }
 
-void test__std__fdiml__leakignore() {
-  char *p = strdup(str);
-  result = std::fdiml(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fdiml__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7640,7 +7016,7 @@ void test__feof__useretval() {
 }
 
 void test__feof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = feof(p);
   // cppcheck-suppress memleak
 }
@@ -7669,12 +7045,6 @@ void test__std__feof__useretval() {
   std::feof(arg1);
 }
 
-void test__std__feof__leakignore() {
-  char *p = strdup(str);
-  result = std::feof(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__feof__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7700,7 +7070,7 @@ void test__ferror__useretval() {
 }
 
 void test__ferror__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ferror(p);
   // cppcheck-suppress memleak
 }
@@ -7729,12 +7099,6 @@ void test__std__ferror__useretval() {
   std::ferror(arg1);
 }
 
-void test__std__ferror__leakignore() {
-  char *p = strdup(str);
-  result = std::ferror(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ferror__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7755,7 +7119,7 @@ void test__fflush__noreturn() {
 }
 
 void test__fflush__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fflush(p);
   // cppcheck-suppress memleak
 }
@@ -7773,12 +7137,6 @@ void test__std__fflush__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fflush__leakignore() {
-  char *p = strdup(str);
-  std::fflush(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fflush__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -7793,7 +7151,7 @@ void test__fgetc__noreturn() {
 }
 
 void test__fgetc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fgetc(p);
   // cppcheck-suppress memleak
 }
@@ -7817,12 +7175,6 @@ void test__std__fgetc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fgetc__leakignore() {
-  char *p = strdup(str);
-  std::fgetc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fgetc__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7843,7 +7195,7 @@ void test__getc__noreturn() {
 }
 
 void test__getc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getc(p);
   // cppcheck-suppress memleak
 }
@@ -7867,12 +7219,6 @@ void test__std__getc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__getc__leakignore() {
-  char *p = strdup(str);
-  std::getc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__getc__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7893,7 +7239,7 @@ void test__fgetwc__noreturn() {
 }
 
 void test__fgetwc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fgetwc(p);
   // cppcheck-suppress memleak
 }
@@ -7917,12 +7263,6 @@ void test__std__fgetwc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fgetwc__leakignore() {
-  char *p = strdup(str);
-  std::fgetwc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fgetwc__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7943,7 +7283,7 @@ void test__getwc__noreturn() {
 }
 
 void test__getwc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getwc(p);
   // cppcheck-suppress memleak
 }
@@ -7967,12 +7307,6 @@ void test__std__getwc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__getwc__leakignore() {
-  char *p = strdup(str);
-  std::getwc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__getwc__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -7993,7 +7327,7 @@ void test__fgetpos__noreturn() {
 }
 
 void test__fgetpos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fgetpos(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8023,12 +7357,6 @@ void test__std__fgetpos__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fgetpos__leakignore() {
-  char *p = strdup(str);
-  std::fgetpos(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fgetpos__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -8065,7 +7393,7 @@ void test__floor__pure(int arg1) {
 }
 
 void test__floor__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = floor(p);
   // cppcheck-suppress memleak
 }
@@ -8093,12 +7421,6 @@ void test__std__floor__pure(int arg1) {
   if ((std::floor(arg1) > 10) || (std::floor(arg1) < 100)) {}
 }
 
-void test__std__floor__leakignore() {
-  char *p = strdup(str);
-  result = std::floor(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__floor__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8123,7 +7445,7 @@ void test__floorf__pure(int arg1) {
 }
 
 void test__floorf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = floorf(p);
   // cppcheck-suppress memleak
 }
@@ -8151,12 +7473,6 @@ void test__std__floorf__pure(int arg1) {
   if ((std::floorf(arg1) > 10) || (std::floorf(arg1) < 100)) {}
 }
 
-void test__std__floorf__leakignore() {
-  char *p = strdup(str);
-  result = std::floorf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__floorf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8181,7 +7497,7 @@ void test__floorl__pure(int arg1) {
 }
 
 void test__floorl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = floorl(p);
   // cppcheck-suppress memleak
 }
@@ -8209,12 +7525,6 @@ void test__std__floorl__pure(int arg1) {
   if ((std::floorl(arg1) > 10) || (std::floorl(arg1) < 100)) {}
 }
 
-void test__std__floorl__leakignore() {
-  char *p = strdup(str);
-  result = std::floorl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__floorl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8239,7 +7549,7 @@ void test__fma__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__fma__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fma(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8279,12 +7589,6 @@ void test__std__fma__pure(int arg1,int arg2,int arg3) {
   if ((std::fma(arg1, arg2, arg3) > 10) || (std::fma(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__fma__leakignore() {
-  char *p = strdup(str);
-  result = std::fma(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fma__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8321,7 +7625,7 @@ void test__fmaf__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__fmaf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmaf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8361,12 +7665,6 @@ void test__std__fmaf__pure(int arg1,int arg2,int arg3) {
   if ((std::fmaf(arg1, arg2, arg3) > 10) || (std::fmaf(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__fmaf__leakignore() {
-  char *p = strdup(str);
-  result = std::fmaf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmaf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8403,7 +7701,7 @@ void test__fmal__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__fmal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmal(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8443,12 +7741,6 @@ void test__std__fmal__pure(int arg1,int arg2,int arg3) {
   if ((std::fmal(arg1, arg2, arg3) > 10) || (std::fmal(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__fmal__leakignore() {
-  char *p = strdup(str);
-  result = std::fmal(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8485,7 +7777,7 @@ void test__fmax__pure(int arg1,int arg2) {
 }
 
 void test__fmax__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmax(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8519,12 +7811,6 @@ void test__std__fmax__pure(int arg1,int arg2) {
   if ((std::fmax(arg1, arg2) > 10) || (std::fmax(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmax__leakignore() {
-  char *p = strdup(str);
-  result = std::fmax(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmax__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8555,7 +7841,7 @@ void test__fmaxf__pure(int arg1,int arg2) {
 }
 
 void test__fmaxf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmaxf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8589,12 +7875,6 @@ void test__std__fmaxf__pure(int arg1,int arg2) {
   if ((std::fmaxf(arg1, arg2) > 10) || (std::fmaxf(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmaxf__leakignore() {
-  char *p = strdup(str);
-  result = std::fmaxf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmaxf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8625,7 +7905,7 @@ void test__fmaxl__pure(int arg1,int arg2) {
 }
 
 void test__fmaxl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmaxl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8659,12 +7939,6 @@ void test__std__fmaxl__pure(int arg1,int arg2) {
   if ((std::fmaxl(arg1, arg2) > 10) || (std::fmaxl(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmaxl__leakignore() {
-  char *p = strdup(str);
-  result = std::fmaxl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmaxl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8695,7 +7969,7 @@ void test__fmin__pure(int arg1,int arg2) {
 }
 
 void test__fmin__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmin(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8729,12 +8003,6 @@ void test__std__fmin__pure(int arg1,int arg2) {
   if ((std::fmin(arg1, arg2) > 10) || (std::fmin(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmin__leakignore() {
-  char *p = strdup(str);
-  result = std::fmin(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmin__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8765,7 +8033,7 @@ void test__fminf__pure(int arg1,int arg2) {
 }
 
 void test__fminf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fminf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8799,12 +8067,6 @@ void test__std__fminf__pure(int arg1,int arg2) {
   if ((std::fminf(arg1, arg2) > 10) || (std::fminf(arg1, arg2) < 100)) {}
 }
 
-void test__std__fminf__leakignore() {
-  char *p = strdup(str);
-  result = std::fminf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fminf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8835,7 +8097,7 @@ void test__fminl__pure(int arg1,int arg2) {
 }
 
 void test__fminl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fminl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8869,12 +8131,6 @@ void test__std__fminl__pure(int arg1,int arg2) {
   if ((std::fminl(arg1, arg2) > 10) || (std::fminl(arg1, arg2) < 100)) {}
 }
 
-void test__std__fminl__leakignore() {
-  char *p = strdup(str);
-  result = std::fminl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fminl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8905,7 +8161,7 @@ void test__fmod__pure(int arg1,int arg2) {
 }
 
 void test__fmod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8939,12 +8195,6 @@ void test__std__fmod__pure(int arg1,int arg2) {
   if ((std::fmod(arg1, arg2) > 10) || (std::fmod(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmod__leakignore() {
-  char *p = strdup(str);
-  result = std::fmod(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmod__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -8975,7 +8225,7 @@ void test__fmodf__pure(int arg1,int arg2) {
 }
 
 void test__fmodf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmodf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9009,12 +8259,6 @@ void test__std__fmodf__pure(int arg1,int arg2) {
   if ((std::fmodf(arg1, arg2) > 10) || (std::fmodf(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmodf__leakignore() {
-  char *p = strdup(str);
-  result = std::fmodf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmodf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -9045,7 +8289,7 @@ void test__fmodl__pure(int arg1,int arg2) {
 }
 
 void test__fmodl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fmodl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9079,12 +8323,6 @@ void test__std__fmodl__pure(int arg1,int arg2) {
   if ((std::fmodl(arg1, arg2) > 10) || (std::fmodl(arg1, arg2) < 100)) {}
 }
 
-void test__std__fmodl__leakignore() {
-  char *p = strdup(str);
-  result = std::fmodl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fmodl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -9214,7 +8452,7 @@ void test__fprintf__noreturn() {
 }
 
 void test__fprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9244,12 +8482,6 @@ void test__std__fprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fprintf__leakignore() {
-  char *p = strdup(str);
-  std::fprintf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9276,7 +8508,7 @@ void test__vfprintf__noreturn() {
 }
 
 void test__vfprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9306,12 +8538,6 @@ void test__std__vfprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vfprintf__leakignore() {
-  char *p = strdup(str);
-  std::vfprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vfprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9338,7 +8564,7 @@ void test__vfwprintf__noreturn() {
 }
 
 void test__vfwprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfwprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9368,12 +8594,6 @@ void test__std__vfwprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vfwprintf__leakignore() {
-  char *p = strdup(str);
-  std::vfwprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vfwprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9400,7 +8620,7 @@ void test__fputc__noreturn() {
 }
 
 void test__fputc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fputc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9435,12 +8655,6 @@ void test__std__fputc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fputc__leakignore() {
-  char *p = strdup(str);
-  std::fputc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fputc__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   std::fputc(!x, arg2);
@@ -9472,7 +8686,7 @@ void test__fputwc__noreturn() {
 }
 
 void test__fputwc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fputwc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9507,12 +8721,6 @@ void test__std__fputwc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fputwc__leakignore() {
-  char *p = strdup(str);
-  std::fputwc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fputwc__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   std::fputwc(!x, arg2);
@@ -9544,7 +8752,7 @@ void test__fputs__noreturn() {
 }
 
 void test__fputs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fputs(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9580,12 +8788,6 @@ void test__std__fputs__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fputs__leakignore() {
-  char *p = strdup(str);
-  std::fputs(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fputs__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9618,7 +8820,7 @@ void test__fputws__noreturn() {
 }
 
 void test__fputws__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fputws(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9654,12 +8856,6 @@ void test__std__fputws__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fputws__leakignore() {
-  char *p = strdup(str);
-  std::fputws(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fputws__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9692,7 +8888,7 @@ void test__fread__noreturn() {
 }
 
 void test__fread__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fread(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9734,12 +8930,6 @@ void test__std__fread__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fread__leakignore() {
-  char *p = strdup(str);
-  std::fread(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fread__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -9936,7 +9126,7 @@ void test__frexp__noreturn() {
 }
 
 void test__frexp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   frexp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9960,12 +9150,6 @@ void test__std__frexp__noreturn() {
   x = 1 << x;
 }
 
-void test__std__frexp__leakignore() {
-  char *p = strdup(str);
-  std::frexp(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__frexp__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -9986,7 +9170,7 @@ void test__frexpf__noreturn() {
 }
 
 void test__frexpf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   frexpf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10010,12 +9194,6 @@ void test__std__frexpf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__frexpf__leakignore() {
-  char *p = strdup(str);
-  std::frexpf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__frexpf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10036,7 +9214,7 @@ void test__frexpl__noreturn() {
 }
 
 void test__frexpl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   frexpl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10060,12 +9238,6 @@ void test__std__frexpl__noreturn() {
   x = 1 << x;
 }
 
-void test__std__frexpl__leakignore() {
-  char *p = strdup(str);
-  std::frexpl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__frexpl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10096,7 +9268,7 @@ void test__hypot__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__hypot__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = hypot(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10136,12 +9308,6 @@ void test__std__hypot__pure(int arg1,int arg2,int arg3) {
   if ((std::hypot(arg1, arg2, arg3) > 10) || (std::hypot(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__hypot__leakignore() {
-  char *p = strdup(str);
-  result = std::hypot(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__hypot__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10178,7 +9344,7 @@ void test__hypotf__pure(int arg1,int arg2) {
 }
 
 void test__hypotf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = hypotf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10212,12 +9378,6 @@ void test__std__hypotf__pure(int arg1,int arg2) {
   if ((std::hypotf(arg1, arg2) > 10) || (std::hypotf(arg1, arg2) < 100)) {}
 }
 
-void test__std__hypotf__leakignore() {
-  char *p = strdup(str);
-  result = std::hypotf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__hypotf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10248,7 +9408,7 @@ void test__hypotl__pure(int arg1,int arg2) {
 }
 
 void test__hypotl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = hypotl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10282,12 +9442,6 @@ void test__std__hypotl__pure(int arg1,int arg2) {
   if ((std::hypotl(arg1, arg2) > 10) || (std::hypotl(arg1, arg2) < 100)) {}
 }
 
-void test__std__hypotl__leakignore() {
-  char *p = strdup(str);
-  result = std::hypotl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__hypotl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10308,7 +9462,7 @@ void test__fscanf__noreturn() {
 }
 
 void test__fscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10332,12 +9486,6 @@ void test__std__fscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fscanf__leakignore() {
-  char *p = strdup(str);
-  std::fscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10358,7 +9506,7 @@ void test__vfscanf__noreturn() {
 }
 
 void test__vfscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfscanf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10382,12 +9530,6 @@ void test__std__vfscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vfscanf__leakignore() {
-  char *p = strdup(str);
-  std::vfscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vfscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10408,7 +9550,7 @@ void test__vfwscanf__noreturn() {
 }
 
 void test__vfwscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vfwscanf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10438,12 +9580,6 @@ void test__std__vfwscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vfwscanf__leakignore() {
-  char *p = strdup(str);
-  std::vfwscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vfwscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -10470,7 +9606,7 @@ void test__fseek__noreturn() {
 }
 
 void test__fseek__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fseek(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10506,12 +9642,6 @@ void test__std__fseek__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fseek__leakignore() {
-  char *p = strdup(str);
-  std::fseek(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fseek__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10544,7 +9674,7 @@ void test__fsetpos__noreturn() {
 }
 
 void test__fsetpos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fsetpos(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10580,12 +9710,6 @@ void test__std__fsetpos__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fsetpos__leakignore() {
-  char *p = strdup(str);
-  std::fsetpos(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fsetpos__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10618,7 +9742,7 @@ void test__fgets__noreturn() {
 }
 
 void test__fgets__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fgets(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10659,12 +9783,6 @@ void test__std__fgets__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fgets__leakignore() {
-  char *p = strdup(str);
-  std::fgets(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fgets__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10702,7 +9820,7 @@ void test__fgetws__noreturn() {
 }
 
 void test__fgetws__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fgetws(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10743,12 +9861,6 @@ void test__std__fgetws__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fgetws__leakignore() {
-  char *p = strdup(str);
-  std::fgetws(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fgetws__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10791,7 +9903,7 @@ void test__ftell__useretval() {
 }
 
 void test__ftell__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ftell(p);
   // cppcheck-suppress memleak
 }
@@ -10820,12 +9932,6 @@ void test__std__ftell__useretval() {
   std::ftell(arg1);
 }
 
-void test__std__ftell__leakignore() {
-  char *p = strdup(str);
-  result = std::ftell(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ftell__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10846,7 +9952,7 @@ void test__fwide__noreturn() {
 }
 
 void test__fwide__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fwide(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10876,12 +9982,6 @@ void test__std__fwide__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fwide__leakignore() {
-  char *p = strdup(str);
-  std::fwide(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fwide__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -10908,7 +10008,7 @@ void test__fwrite__noreturn() {
 }
 
 void test__fwrite__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fwrite(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10956,12 +10056,6 @@ void test__std__fwrite__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fwrite__leakignore() {
-  char *p = strdup(str);
-  std::fwrite(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fwrite__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11006,7 +10100,7 @@ void test__mblen__noreturn() {
 }
 
 void test__mblen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mblen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11030,12 +10124,6 @@ void test__std__mblen__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mblen__leakignore() {
-  char *p = strdup(str);
-  std::mblen(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mblen__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11056,7 +10144,7 @@ void test__mbtowc__noreturn() {
 }
 
 void test__mbtowc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbtowc(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -11080,12 +10168,6 @@ void test__std__mbtowc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbtowc__leakignore() {
-  char *p = strdup(str);
-  std::mbtowc(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbtowc__arg2__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11106,7 +10188,7 @@ void test__mbrlen__noreturn() {
 }
 
 void test__mbrlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbrlen(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -11142,12 +10224,6 @@ void test__std__mbrlen__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbrlen__leakignore() {
-  char *p = strdup(str);
-  std::mbrlen(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbrlen__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11190,7 +10266,7 @@ void test__btowc__pure(int arg1) {
 }
 
 void test__btowc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = btowc(p);
   // cppcheck-suppress memleak
 }
@@ -11218,12 +10294,6 @@ void test__std__btowc__pure(int arg1) {
   if ((std::btowc(arg1) > 10) || (std::btowc(arg1) < 100)) {}
 }
 
-void test__std__btowc__leakignore() {
-  char *p = strdup(str);
-  result = std::btowc(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__btowc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11238,7 +10308,7 @@ void test__mbsinit__noreturn() {
 }
 
 void test__mbsinit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbsinit(p);
   // cppcheck-suppress memleak
 }
@@ -11256,12 +10326,6 @@ void test__std__mbsinit__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbsinit__leakignore() {
-  char *p = strdup(str);
-  std::mbsinit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbsinit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11276,7 +10340,7 @@ void test__getwchar__noreturn() {
 }
 
 void test__getwchar__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getwchar();
   // cppcheck-suppress memleak
 }
@@ -11289,7 +10353,7 @@ void test__mbstowcs__noreturn() {
 }
 
 void test__mbstowcs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbstowcs(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -11319,12 +10383,6 @@ void test__std__mbstowcs__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbstowcs__leakignore() {
-  char *p = strdup(str);
-  std::mbstowcs(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbstowcs__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11351,7 +10409,7 @@ void test__mbsrtowcs__noreturn() {
 }
 
 void test__mbsrtowcs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbsrtowcs(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -11387,12 +10445,6 @@ void test__std__mbsrtowcs__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbsrtowcs__leakignore() {
-  char *p = strdup(str);
-  std::mbsrtowcs(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbsrtowcs__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11435,7 +10487,7 @@ void test__wctob__pure(int arg1) {
 }
 
 void test__wctob__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wctob(p);
   // cppcheck-suppress memleak
 }
@@ -11463,12 +10515,6 @@ void test__std__wctob__pure(int arg1) {
   if ((std::wctob(arg1) > 10) || (std::wctob(arg1) < 100)) {}
 }
 
-void test__std__wctob__leakignore() {
-  char *p = strdup(str);
-  result = std::wctob(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wctob__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11483,7 +10529,7 @@ void test__wctomb__noreturn() {
 }
 
 void test__wctomb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wctomb(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11507,12 +10553,6 @@ void test__std__wctomb__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wctomb__leakignore() {
-  char *p = strdup(str);
-  std::wctomb(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wctomb__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11533,7 +10573,7 @@ void test__wcstombs__noreturn() {
 }
 
 void test__wcstombs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstombs(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -11563,12 +10603,6 @@ void test__std__wcstombs__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstombs__leakignore() {
-  char *p = strdup(str);
-  std::wcstombs(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstombs__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11595,7 +10629,7 @@ void test__getchar__noreturn() {
 }
 
 void test__getchar__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getchar();
   // cppcheck-suppress memleak
 }
@@ -11608,7 +10642,7 @@ void test__ungetc__noreturn() {
 }
 
 void test__ungetc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ungetc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11638,12 +10672,6 @@ void test__std__ungetc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ungetc__leakignore() {
-  char *p = strdup(str);
-  std::ungetc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ungetc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11670,7 +10698,7 @@ void test__ungetwc__noreturn() {
 }
 
 void test__ungetwc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ungetwc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11700,12 +10728,6 @@ void test__std__ungetwc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ungetwc__leakignore() {
-  char *p = strdup(str);
-  std::ungetwc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ungetwc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -11737,7 +10759,7 @@ void test__getenv__useretval() {
 }
 
 void test__getenv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = getenv(p);
   // cppcheck-suppress memleak
 }
@@ -11766,12 +10788,6 @@ void test__std__getenv__useretval() {
   std::getenv(arg1);
 }
 
-void test__std__getenv__leakignore() {
-  char *p = strdup(str);
-  result = std::getenv(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__getenv__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11792,7 +10808,7 @@ void test__gets__noreturn() {
 }
 
 void test__gets__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   gets(p);
   // cppcheck-suppress memleak
 }
@@ -11810,12 +10826,6 @@ void test__std__gets__noreturn() {
   x = 1 << x;
 }
 
-void test__std__gets__leakignore() {
-  char *p = strdup(str);
-  std::gets(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__gets__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11830,7 +10840,7 @@ void test__gets_s__noreturn() {
 }
 
 void test__gets_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   gets_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11859,12 +10869,6 @@ void test__std__gets_s__noreturn() {
   x = 1 << x;
 }
 
-void test__std__gets_s__leakignore() {
-  char *p = strdup(str);
-  std::gets_s(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__gets_s__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11900,7 +10904,7 @@ void test__gmtime__pure(int arg1) {
 }
 
 void test__gmtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = gmtime(p);
   // cppcheck-suppress memleak
 }
@@ -11934,12 +10938,6 @@ void test__std__gmtime__pure(int arg1) {
   if ((std::gmtime(arg1) > 10) || (std::gmtime(arg1) < 100)) {}
 }
 
-void test__std__gmtime__leakignore() {
-  char *p = strdup(str);
-  result = std::gmtime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__gmtime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -11970,7 +10968,7 @@ void test__isalnum__pure(int arg1) {
 }
 
 void test__isalnum__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isalnum(p);
   // cppcheck-suppress memleak
 }
@@ -11998,12 +10996,6 @@ void test__std__isalnum__pure(int arg1) {
   if ((std::isalnum(arg1) > 10) || (std::isalnum(arg1) < 100)) {}
 }
 
-void test__std__isalnum__leakignore() {
-  char *p = strdup(str);
-  result = std::isalnum(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isalnum__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12028,7 +11020,7 @@ void test__iswalnum__pure(int arg1) {
 }
 
 void test__iswalnum__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswalnum(p);
   // cppcheck-suppress memleak
 }
@@ -12056,12 +11048,6 @@ void test__std__iswalnum__pure(int arg1) {
   if ((std::iswalnum(arg1) > 10) || (std::iswalnum(arg1) < 100)) {}
 }
 
-void test__std__iswalnum__leakignore() {
-  char *p = strdup(str);
-  result = std::iswalnum(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswalnum__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12086,7 +11072,7 @@ void test__isalpha__pure(int arg1) {
 }
 
 void test__isalpha__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isalpha(p);
   // cppcheck-suppress memleak
 }
@@ -12114,12 +11100,6 @@ void test__std__isalpha__pure(int arg1) {
   if ((std::isalpha(arg1) > 10) || (std::isalpha(arg1) < 100)) {}
 }
 
-void test__std__isalpha__leakignore() {
-  char *p = strdup(str);
-  result = std::isalpha(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isalpha__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12144,7 +11124,7 @@ void test__iswalpha__pure(int arg1) {
 }
 
 void test__iswalpha__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswalpha(p);
   // cppcheck-suppress memleak
 }
@@ -12172,12 +11152,6 @@ void test__std__iswalpha__pure(int arg1) {
   if ((std::iswalpha(arg1) > 10) || (std::iswalpha(arg1) < 100)) {}
 }
 
-void test__std__iswalpha__leakignore() {
-  char *p = strdup(str);
-  result = std::iswalpha(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswalpha__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12202,7 +11176,7 @@ void test__isblank__pure(int arg1) {
 }
 
 void test__isblank__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isblank(p);
   // cppcheck-suppress memleak
 }
@@ -12230,12 +11204,6 @@ void test__std__isblank__pure(int arg1) {
   if ((std::isblank(arg1) > 10) || (std::isblank(arg1) < 100)) {}
 }
 
-void test__std__isblank__leakignore() {
-  char *p = strdup(str);
-  result = std::isblank(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isblank__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12260,7 +11228,7 @@ void test__iswblank__pure(int arg1) {
 }
 
 void test__iswblank__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswblank(p);
   // cppcheck-suppress memleak
 }
@@ -12288,12 +11256,6 @@ void test__std__iswblank__pure(int arg1) {
   if ((std::iswblank(arg1) > 10) || (std::iswblank(arg1) < 100)) {}
 }
 
-void test__std__iswblank__leakignore() {
-  char *p = strdup(str);
-  result = std::iswblank(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswblank__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12318,7 +11280,7 @@ void test__iscntrl__pure(int arg1) {
 }
 
 void test__iscntrl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iscntrl(p);
   // cppcheck-suppress memleak
 }
@@ -12346,12 +11308,6 @@ void test__std__iscntrl__pure(int arg1) {
   if ((std::iscntrl(arg1) > 10) || (std::iscntrl(arg1) < 100)) {}
 }
 
-void test__std__iscntrl__leakignore() {
-  char *p = strdup(str);
-  result = std::iscntrl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iscntrl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12376,7 +11332,7 @@ void test__iswcntrl__pure(int arg1) {
 }
 
 void test__iswcntrl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswcntrl(p);
   // cppcheck-suppress memleak
 }
@@ -12404,12 +11360,6 @@ void test__std__iswcntrl__pure(int arg1) {
   if ((std::iswcntrl(arg1) > 10) || (std::iswcntrl(arg1) < 100)) {}
 }
 
-void test__std__iswcntrl__leakignore() {
-  char *p = strdup(str);
-  result = std::iswcntrl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswcntrl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12434,7 +11384,7 @@ void test__iswctype__pure(int arg1,int arg2) {
 }
 
 void test__iswctype__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswctype(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -12468,12 +11418,6 @@ void test__std__iswctype__pure(int arg1,int arg2) {
   if ((std::iswctype(arg1, arg2) > 10) || (std::iswctype(arg1, arg2) < 100)) {}
 }
 
-void test__std__iswctype__leakignore() {
-  char *p = strdup(str);
-  result = std::iswctype(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswctype__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12504,7 +11448,7 @@ void test__isdigit__pure(int arg1) {
 }
 
 void test__isdigit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isdigit(p);
   // cppcheck-suppress memleak
 }
@@ -12532,12 +11476,6 @@ void test__std__isdigit__pure(int arg1) {
   if ((std::isdigit(arg1) > 10) || (std::isdigit(arg1) < 100)) {}
 }
 
-void test__std__isdigit__leakignore() {
-  char *p = strdup(str);
-  result = std::isdigit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isdigit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12562,7 +11500,7 @@ void test__iswdigit__pure(int arg1) {
 }
 
 void test__iswdigit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswdigit(p);
   // cppcheck-suppress memleak
 }
@@ -12590,12 +11528,6 @@ void test__std__iswdigit__pure(int arg1) {
   if ((std::iswdigit(arg1) > 10) || (std::iswdigit(arg1) < 100)) {}
 }
 
-void test__std__iswdigit__leakignore() {
-  char *p = strdup(str);
-  result = std::iswdigit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswdigit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12620,7 +11552,7 @@ void test__isgraph__pure(int arg1) {
 }
 
 void test__isgraph__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isgraph(p);
   // cppcheck-suppress memleak
 }
@@ -12648,12 +11580,6 @@ void test__std__isgraph__pure(int arg1) {
   if ((std::isgraph(arg1) > 10) || (std::isgraph(arg1) < 100)) {}
 }
 
-void test__std__isgraph__leakignore() {
-  char *p = strdup(str);
-  result = std::isgraph(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isgraph__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12678,7 +11604,7 @@ void test__iswgraph__pure(int arg1) {
 }
 
 void test__iswgraph__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswgraph(p);
   // cppcheck-suppress memleak
 }
@@ -12706,12 +11632,6 @@ void test__std__iswgraph__pure(int arg1) {
   if ((std::iswgraph(arg1) > 10) || (std::iswgraph(arg1) < 100)) {}
 }
 
-void test__std__iswgraph__leakignore() {
-  char *p = strdup(str);
-  result = std::iswgraph(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswgraph__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12736,7 +11656,7 @@ void test__islower__pure(int arg1) {
 }
 
 void test__islower__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = islower(p);
   // cppcheck-suppress memleak
 }
@@ -12764,12 +11684,6 @@ void test__std__islower__pure(int arg1) {
   if ((std::islower(arg1) > 10) || (std::islower(arg1) < 100)) {}
 }
 
-void test__std__islower__leakignore() {
-  char *p = strdup(str);
-  result = std::islower(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__islower__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12794,7 +11708,7 @@ void test__iswlower__pure(int arg1) {
 }
 
 void test__iswlower__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswlower(p);
   // cppcheck-suppress memleak
 }
@@ -12822,12 +11736,6 @@ void test__std__iswlower__pure(int arg1) {
   if ((std::iswlower(arg1) > 10) || (std::iswlower(arg1) < 100)) {}
 }
 
-void test__std__iswlower__leakignore() {
-  char *p = strdup(str);
-  result = std::iswlower(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswlower__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12852,7 +11760,7 @@ void test__isprint__pure(int arg1) {
 }
 
 void test__isprint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isprint(p);
   // cppcheck-suppress memleak
 }
@@ -12880,12 +11788,6 @@ void test__std__isprint__pure(int arg1) {
   if ((std::isprint(arg1) > 10) || (std::isprint(arg1) < 100)) {}
 }
 
-void test__std__isprint__leakignore() {
-  char *p = strdup(str);
-  result = std::isprint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isprint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12910,7 +11812,7 @@ void test__iswprint__pure(int arg1) {
 }
 
 void test__iswprint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswprint(p);
   // cppcheck-suppress memleak
 }
@@ -12938,12 +11840,6 @@ void test__std__iswprint__pure(int arg1) {
   if ((std::iswprint(arg1) > 10) || (std::iswprint(arg1) < 100)) {}
 }
 
-void test__std__iswprint__leakignore() {
-  char *p = strdup(str);
-  result = std::iswprint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswprint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -12968,7 +11864,7 @@ void test__ispunct__pure(int arg1) {
 }
 
 void test__ispunct__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ispunct(p);
   // cppcheck-suppress memleak
 }
@@ -12996,12 +11892,6 @@ void test__std__ispunct__pure(int arg1) {
   if ((std::ispunct(arg1) > 10) || (std::ispunct(arg1) < 100)) {}
 }
 
-void test__std__ispunct__leakignore() {
-  char *p = strdup(str);
-  result = std::ispunct(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ispunct__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13026,7 +11916,7 @@ void test__iswpunct__pure(int arg1) {
 }
 
 void test__iswpunct__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswpunct(p);
   // cppcheck-suppress memleak
 }
@@ -13054,12 +11944,6 @@ void test__std__iswpunct__pure(int arg1) {
   if ((std::iswpunct(arg1) > 10) || (std::iswpunct(arg1) < 100)) {}
 }
 
-void test__std__iswpunct__leakignore() {
-  char *p = strdup(str);
-  result = std::iswpunct(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswpunct__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13084,7 +11968,7 @@ void test__isspace__pure(int arg1) {
 }
 
 void test__isspace__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isspace(p);
   // cppcheck-suppress memleak
 }
@@ -13112,12 +11996,6 @@ void test__std__isspace__pure(int arg1) {
   if ((std::isspace(arg1) > 10) || (std::isspace(arg1) < 100)) {}
 }
 
-void test__std__isspace__leakignore() {
-  char *p = strdup(str);
-  result = std::isspace(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isspace__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13142,7 +12020,7 @@ void test__iswspace__pure(int arg1) {
 }
 
 void test__iswspace__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswspace(p);
   // cppcheck-suppress memleak
 }
@@ -13170,12 +12048,6 @@ void test__std__iswspace__pure(int arg1) {
   if ((std::iswspace(arg1) > 10) || (std::iswspace(arg1) < 100)) {}
 }
 
-void test__std__iswspace__leakignore() {
-  char *p = strdup(str);
-  result = std::iswspace(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswspace__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13200,7 +12072,7 @@ void test__isupper__pure(int arg1) {
 }
 
 void test__isupper__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isupper(p);
   // cppcheck-suppress memleak
 }
@@ -13228,12 +12100,6 @@ void test__std__isupper__pure(int arg1) {
   if ((std::isupper(arg1) > 10) || (std::isupper(arg1) < 100)) {}
 }
 
-void test__std__isupper__leakignore() {
-  char *p = strdup(str);
-  result = std::isupper(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isupper__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13258,7 +12124,7 @@ void test__iswupper__pure(int arg1) {
 }
 
 void test__iswupper__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswupper(p);
   // cppcheck-suppress memleak
 }
@@ -13286,12 +12152,6 @@ void test__std__iswupper__pure(int arg1) {
   if ((std::iswupper(arg1) > 10) || (std::iswupper(arg1) < 100)) {}
 }
 
-void test__std__iswupper__leakignore() {
-  char *p = strdup(str);
-  result = std::iswupper(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswupper__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13316,7 +12176,7 @@ void test__isxdigit__pure(int arg1) {
 }
 
 void test__isxdigit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isxdigit(p);
   // cppcheck-suppress memleak
 }
@@ -13344,12 +12204,6 @@ void test__std__isxdigit__pure(int arg1) {
   if ((std::isxdigit(arg1) > 10) || (std::isxdigit(arg1) < 100)) {}
 }
 
-void test__std__isxdigit__leakignore() {
-  char *p = strdup(str);
-  result = std::isxdigit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isxdigit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13374,7 +12228,7 @@ void test__iswxdigit__pure(int arg1) {
 }
 
 void test__iswxdigit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = iswxdigit(p);
   // cppcheck-suppress memleak
 }
@@ -13402,12 +12256,6 @@ void test__std__iswxdigit__pure(int arg1) {
   if ((std::iswxdigit(arg1) > 10) || (std::iswxdigit(arg1) < 100)) {}
 }
 
-void test__std__iswxdigit__leakignore() {
-  char *p = strdup(str);
-  result = std::iswxdigit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__iswxdigit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13432,7 +12280,7 @@ void test__towctrans__pure(int arg1,int arg2) {
 }
 
 void test__towctrans__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = towctrans(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -13466,12 +12314,6 @@ void test__std__towctrans__pure(int arg1,int arg2) {
   if ((std::towctrans(arg1, arg2) > 10) || (std::towctrans(arg1, arg2) < 100)) {}
 }
 
-void test__std__towctrans__leakignore() {
-  char *p = strdup(str);
-  result = std::towctrans(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__towctrans__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13502,7 +12344,7 @@ void test__towlower__pure(int arg1) {
 }
 
 void test__towlower__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = towlower(p);
   // cppcheck-suppress memleak
 }
@@ -13530,12 +12372,6 @@ void test__std__towlower__pure(int arg1) {
   if ((std::towlower(arg1) > 10) || (std::towlower(arg1) < 100)) {}
 }
 
-void test__std__towlower__leakignore() {
-  char *p = strdup(str);
-  result = std::towlower(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__towlower__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13560,7 +12396,7 @@ void test__towupper__pure(int arg1) {
 }
 
 void test__towupper__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = towupper(p);
   // cppcheck-suppress memleak
 }
@@ -13588,12 +12424,6 @@ void test__std__towupper__pure(int arg1) {
   if ((std::towupper(arg1) > 10) || (std::towupper(arg1) < 100)) {}
 }
 
-void test__std__towupper__leakignore() {
-  char *p = strdup(str);
-  result = std::towupper(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__towupper__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -13618,7 +12448,7 @@ void test__wctrans__pure(int arg1) {
 }
 
 void test__wctrans__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wctrans(p);
   // cppcheck-suppress memleak
 }
@@ -13652,12 +12482,6 @@ void test__std__wctrans__pure(int arg1) {
   if ((std::wctrans(arg1) > 10) || (std::wctrans(arg1) < 100)) {}
 }
 
-void test__std__wctrans__leakignore() {
-  char *p = strdup(str);
-  result = std::wctrans(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wctrans__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -13688,7 +12512,7 @@ void test__wctype__pure(int arg1) {
 }
 
 void test__wctype__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wctype(p);
   // cppcheck-suppress memleak
 }
@@ -13722,12 +12546,6 @@ void test__std__wctype__pure(int arg1) {
   if ((std::wctype(arg1) > 10) || (std::wctype(arg1) < 100)) {}
 }
 
-void test__std__wctype__leakignore() {
-  char *p = strdup(str);
-  result = std::wctype(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wctype__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -13758,7 +12576,7 @@ void test__cabs__pure(int arg1) {
 }
 
 void test__cabs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cabs(p);
   // cppcheck-suppress memleak
 }
@@ -13787,7 +12605,7 @@ void test__cabsf__pure(int arg1) {
 }
 
 void test__cabsf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cabsf(p);
   // cppcheck-suppress memleak
 }
@@ -13816,7 +12634,7 @@ void test__cabsl__pure(int arg1) {
 }
 
 void test__cabsl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cabsl(p);
   // cppcheck-suppress memleak
 }
@@ -13845,7 +12663,7 @@ void test__cacos__pure(int arg1) {
 }
 
 void test__cacos__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacos(p);
   // cppcheck-suppress memleak
 }
@@ -13874,7 +12692,7 @@ void test__cacosf__pure(int arg1) {
 }
 
 void test__cacosf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacosf(p);
   // cppcheck-suppress memleak
 }
@@ -13903,7 +12721,7 @@ void test__cacosl__pure(int arg1) {
 }
 
 void test__cacosl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacosl(p);
   // cppcheck-suppress memleak
 }
@@ -13932,7 +12750,7 @@ void test__cacosh__pure(int arg1) {
 }
 
 void test__cacosh__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacosh(p);
   // cppcheck-suppress memleak
 }
@@ -13961,7 +12779,7 @@ void test__cacoshf__pure(int arg1) {
 }
 
 void test__cacoshf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacoshf(p);
   // cppcheck-suppress memleak
 }
@@ -13990,7 +12808,7 @@ void test__cacoshl__pure(int arg1) {
 }
 
 void test__cacoshl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cacoshl(p);
   // cppcheck-suppress memleak
 }
@@ -14019,7 +12837,7 @@ void test__labs__pure(int arg1) {
 }
 
 void test__labs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = labs(p);
   // cppcheck-suppress memleak
 }
@@ -14047,12 +12865,6 @@ void test__std__labs__pure(int arg1) {
   if ((std::labs(arg1) > 10) || (std::labs(arg1) < 100)) {}
 }
 
-void test__std__labs__leakignore() {
-  char *p = strdup(str);
-  result = std::labs(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__labs__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14077,7 +12889,7 @@ void test__llabs__pure(int arg1) {
 }
 
 void test__llabs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llabs(p);
   // cppcheck-suppress memleak
 }
@@ -14105,12 +12917,6 @@ void test__std__llabs__pure(int arg1) {
   if ((std::llabs(arg1) > 10) || (std::llabs(arg1) < 100)) {}
 }
 
-void test__std__llabs__leakignore() {
-  char *p = strdup(str);
-  result = std::llabs(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llabs__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14135,7 +12941,7 @@ void test__ldexp__pure(int arg1,int arg2) {
 }
 
 void test__ldexp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ldexp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14169,12 +12975,6 @@ void test__std__ldexp__pure(int arg1,int arg2) {
   if ((std::ldexp(arg1, arg2) > 10) || (std::ldexp(arg1, arg2) < 100)) {}
 }
 
-void test__std__ldexp__leakignore() {
-  char *p = strdup(str);
-  result = std::ldexp(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ldexp__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14205,7 +13005,7 @@ void test__ldexpf__pure(int arg1,int arg2) {
 }
 
 void test__ldexpf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ldexpf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14239,12 +13039,6 @@ void test__std__ldexpf__pure(int arg1,int arg2) {
   if ((std::ldexpf(arg1, arg2) > 10) || (std::ldexpf(arg1, arg2) < 100)) {}
 }
 
-void test__std__ldexpf__leakignore() {
-  char *p = strdup(str);
-  result = std::ldexpf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ldexpf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14275,7 +13069,7 @@ void test__ldexpl__pure(int arg1,int arg2) {
 }
 
 void test__ldexpl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ldexpl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14309,12 +13103,6 @@ void test__std__ldexpl__pure(int arg1,int arg2) {
   if ((std::ldexpl(arg1, arg2) > 10) || (std::ldexpl(arg1, arg2) < 100)) {}
 }
 
-void test__std__ldexpl__leakignore() {
-  char *p = strdup(str);
-  result = std::ldexpl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ldexpl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14345,7 +13133,7 @@ void test__lgamma__pure(int arg1) {
 }
 
 void test__lgamma__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lgamma(p);
   // cppcheck-suppress memleak
 }
@@ -14373,12 +13161,6 @@ void test__std__lgamma__pure(int arg1) {
   if ((std::lgamma(arg1) > 10) || (std::lgamma(arg1) < 100)) {}
 }
 
-void test__std__lgamma__leakignore() {
-  char *p = strdup(str);
-  result = std::lgamma(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lgamma__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14403,7 +13185,7 @@ void test__lgammaf__pure(int arg1) {
 }
 
 void test__lgammaf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lgammaf(p);
   // cppcheck-suppress memleak
 }
@@ -14431,12 +13213,6 @@ void test__std__lgammaf__pure(int arg1) {
   if ((std::lgammaf(arg1) > 10) || (std::lgammaf(arg1) < 100)) {}
 }
 
-void test__std__lgammaf__leakignore() {
-  char *p = strdup(str);
-  result = std::lgammaf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lgammaf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14461,7 +13237,7 @@ void test__lgammal__pure(int arg1) {
 }
 
 void test__lgammal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lgammal(p);
   // cppcheck-suppress memleak
 }
@@ -14489,12 +13265,6 @@ void test__std__lgammal__pure(int arg1) {
   if ((std::lgammal(arg1) > 10) || (std::lgammal(arg1) < 100)) {}
 }
 
-void test__std__lgammal__leakignore() {
-  char *p = strdup(str);
-  result = std::lgammal(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lgammal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14519,7 +13289,7 @@ void test__rint__pure(int arg1) {
 }
 
 void test__rint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = rint(p);
   // cppcheck-suppress memleak
 }
@@ -14547,12 +13317,6 @@ void test__std__rint__pure(int arg1) {
   if ((std::rint(arg1) > 10) || (std::rint(arg1) < 100)) {}
 }
 
-void test__std__rint__leakignore() {
-  char *p = strdup(str);
-  result = std::rint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__rint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14577,7 +13341,7 @@ void test__rintf__pure(int arg1) {
 }
 
 void test__rintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = rintf(p);
   // cppcheck-suppress memleak
 }
@@ -14605,12 +13369,6 @@ void test__std__rintf__pure(int arg1) {
   if ((std::rintf(arg1) > 10) || (std::rintf(arg1) < 100)) {}
 }
 
-void test__std__rintf__leakignore() {
-  char *p = strdup(str);
-  result = std::rintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__rintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14635,7 +13393,7 @@ void test__rintl__pure(int arg1) {
 }
 
 void test__rintl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = rintl(p);
   // cppcheck-suppress memleak
 }
@@ -14663,12 +13421,6 @@ void test__std__rintl__pure(int arg1) {
   if ((std::rintl(arg1) > 10) || (std::rintl(arg1) < 100)) {}
 }
 
-void test__std__rintl__leakignore() {
-  char *p = strdup(str);
-  result = std::rintl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__rintl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14693,7 +13445,7 @@ void test__lrint__pure(int arg1) {
 }
 
 void test__lrint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lrint(p);
   // cppcheck-suppress memleak
 }
@@ -14721,12 +13473,6 @@ void test__std__lrint__pure(int arg1) {
   if ((std::lrint(arg1) > 10) || (std::lrint(arg1) < 100)) {}
 }
 
-void test__std__lrint__leakignore() {
-  char *p = strdup(str);
-  result = std::lrint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lrint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14751,7 +13497,7 @@ void test__lrintf__pure(int arg1) {
 }
 
 void test__lrintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lrintf(p);
   // cppcheck-suppress memleak
 }
@@ -14779,12 +13525,6 @@ void test__std__lrintf__pure(int arg1) {
   if ((std::lrintf(arg1) > 10) || (std::lrintf(arg1) < 100)) {}
 }
 
-void test__std__lrintf__leakignore() {
-  char *p = strdup(str);
-  result = std::lrintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lrintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14809,7 +13549,7 @@ void test__lrintl__pure(int arg1) {
 }
 
 void test__lrintl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lrintl(p);
   // cppcheck-suppress memleak
 }
@@ -14837,12 +13577,6 @@ void test__std__lrintl__pure(int arg1) {
   if ((std::lrintl(arg1) > 10) || (std::lrintl(arg1) < 100)) {}
 }
 
-void test__std__lrintl__leakignore() {
-  char *p = strdup(str);
-  result = std::lrintl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lrintl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14867,7 +13601,7 @@ void test__llrint__pure(int arg1) {
 }
 
 void test__llrint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llrint(p);
   // cppcheck-suppress memleak
 }
@@ -14895,12 +13629,6 @@ void test__std__llrint__pure(int arg1) {
   if ((std::llrint(arg1) > 10) || (std::llrint(arg1) < 100)) {}
 }
 
-void test__std__llrint__leakignore() {
-  char *p = strdup(str);
-  result = std::llrint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llrint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14925,7 +13653,7 @@ void test__llrintf__pure(int arg1) {
 }
 
 void test__llrintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llrintf(p);
   // cppcheck-suppress memleak
 }
@@ -14953,12 +13681,6 @@ void test__std__llrintf__pure(int arg1) {
   if ((std::llrintf(arg1) > 10) || (std::llrintf(arg1) < 100)) {}
 }
 
-void test__std__llrintf__leakignore() {
-  char *p = strdup(str);
-  result = std::llrintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llrintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -14983,7 +13705,7 @@ void test__llrintl__pure(int arg1) {
 }
 
 void test__llrintl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llrintl(p);
   // cppcheck-suppress memleak
 }
@@ -15011,12 +13733,6 @@ void test__std__llrintl__pure(int arg1) {
   if ((std::llrintl(arg1) > 10) || (std::llrintl(arg1) < 100)) {}
 }
 
-void test__std__llrintl__leakignore() {
-  char *p = strdup(str);
-  result = std::llrintl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llrintl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15041,7 +13757,7 @@ void test__llround__pure(int arg1) {
 }
 
 void test__llround__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llround(p);
   // cppcheck-suppress memleak
 }
@@ -15069,12 +13785,6 @@ void test__std__llround__pure(int arg1) {
   if ((std::llround(arg1) > 10) || (std::llround(arg1) < 100)) {}
 }
 
-void test__std__llround__leakignore() {
-  char *p = strdup(str);
-  result = std::llround(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llround__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15099,7 +13809,7 @@ void test__llroundf__pure(int arg1) {
 }
 
 void test__llroundf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llroundf(p);
   // cppcheck-suppress memleak
 }
@@ -15127,12 +13837,6 @@ void test__std__llroundf__pure(int arg1) {
   if ((std::llroundf(arg1) > 10) || (std::llroundf(arg1) < 100)) {}
 }
 
-void test__std__llroundf__leakignore() {
-  char *p = strdup(str);
-  result = std::llroundf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llroundf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15157,7 +13861,7 @@ void test__llroundl__pure(int arg1) {
 }
 
 void test__llroundl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = llroundl(p);
   // cppcheck-suppress memleak
 }
@@ -15185,12 +13889,6 @@ void test__std__llroundl__pure(int arg1) {
   if ((std::llroundl(arg1) > 10) || (std::llroundl(arg1) < 100)) {}
 }
 
-void test__std__llroundl__leakignore() {
-  char *p = strdup(str);
-  result = std::llroundl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__llroundl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15215,7 +13913,7 @@ void test__lround__pure(int arg1) {
 }
 
 void test__lround__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lround(p);
   // cppcheck-suppress memleak
 }
@@ -15243,12 +13941,6 @@ void test__std__lround__pure(int arg1) {
   if ((std::lround(arg1) > 10) || (std::lround(arg1) < 100)) {}
 }
 
-void test__std__lround__leakignore() {
-  char *p = strdup(str);
-  result = std::lround(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lround__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15273,7 +13965,7 @@ void test__lroundf__pure(int arg1) {
 }
 
 void test__lroundf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lroundf(p);
   // cppcheck-suppress memleak
 }
@@ -15301,12 +13993,6 @@ void test__std__lroundf__pure(int arg1) {
   if ((std::lroundf(arg1) > 10) || (std::lroundf(arg1) < 100)) {}
 }
 
-void test__std__lroundf__leakignore() {
-  char *p = strdup(str);
-  result = std::lroundf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lroundf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15331,7 +14017,7 @@ void test__lroundl__pure(int arg1) {
 }
 
 void test__lroundl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = lroundl(p);
   // cppcheck-suppress memleak
 }
@@ -15359,12 +14045,6 @@ void test__std__lroundl__pure(int arg1) {
   if ((std::lroundl(arg1) > 10) || (std::lroundl(arg1) < 100)) {}
 }
 
-void test__std__lroundl__leakignore() {
-  char *p = strdup(str);
-  result = std::lroundl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lroundl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15384,7 +14064,7 @@ void test__rand__useretval() {
 }
 
 void test__rand__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = rand();
   // cppcheck-suppress memleak
 }
@@ -15397,7 +14077,7 @@ void test__srand__noreturn() {
 }
 
 void test__srand__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   srand(p);
   // cppcheck-suppress memleak
 }
@@ -15415,12 +14095,6 @@ void test__std__srand__noreturn() {
   x = 1 << x;
 }
 
-void test__std__srand__leakignore() {
-  char *p = strdup(str);
-  std::srand(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__srand__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15440,7 +14114,7 @@ void test__ldiv__pure(int arg1,int arg2) {
 }
 
 void test__ldiv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ldiv(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -15469,12 +14143,6 @@ void test__std__ldiv__pure(int arg1,int arg2) {
   if ((std::ldiv(arg1, arg2) > 10) || (std::ldiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__ldiv__leakignore() {
-  char *p = strdup(str);
-  std::ldiv(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ldiv__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15500,7 +14168,7 @@ void test__lldiv__pure(int arg1,int arg2) {
 }
 
 void test__lldiv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   lldiv(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -15529,12 +14197,6 @@ void test__std__lldiv__pure(int arg1,int arg2) {
   if ((std::lldiv(arg1, arg2) > 10) || (std::lldiv(arg1, arg2) < 100)) {}
 }
 
-void test__std__lldiv__leakignore() {
-  char *p = strdup(str);
-  std::lldiv(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__lldiv__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15555,7 +14217,7 @@ void test__localtime__noreturn() {
 }
 
 void test__localtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   localtime(p);
   // cppcheck-suppress memleak
 }
@@ -15579,12 +14241,6 @@ void test__std__localtime__noreturn() {
   x = 1 << x;
 }
 
-void test__std__localtime__leakignore() {
-  char *p = strdup(str);
-  std::localtime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__localtime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -15605,7 +14261,7 @@ void test__localtime_s__noreturn() {
 }
 
 void test__localtime_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   localtime_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -15629,12 +14285,6 @@ void test__std__localtime_s__noreturn() {
   x = 1 << x;
 }
 
-void test__std__localtime_s__leakignore() {
-  char *p = strdup(str);
-  std::localtime_s(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__localtime_s__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -15660,7 +14310,7 @@ void test__log__useretval() {
 }
 
 void test__log__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log(p);
   // cppcheck-suppress memleak
 }
@@ -15683,12 +14333,6 @@ void test__std__log__useretval() {
   std::log(arg1);
 }
 
-void test__std__log__leakignore() {
-  char *p = strdup(str);
-  result = std::log(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15708,7 +14352,7 @@ void test__logf__useretval() {
 }
 
 void test__logf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = logf(p);
   // cppcheck-suppress memleak
 }
@@ -15731,12 +14375,6 @@ void test__std__logf__useretval() {
   std::logf(arg1);
 }
 
-void test__std__logf__leakignore() {
-  char *p = strdup(str);
-  result = std::logf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__logf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15756,7 +14394,7 @@ void test__logl__useretval() {
 }
 
 void test__logl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = logl(p);
   // cppcheck-suppress memleak
 }
@@ -15779,12 +14417,6 @@ void test__std__logl__useretval() {
   std::logl(arg1);
 }
 
-void test__std__logl__leakignore() {
-  char *p = strdup(str);
-  result = std::logl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__logl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -15804,7 +14436,7 @@ void test__clog__useretval() {
 }
 
 void test__clog__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = clog(p);
   // cppcheck-suppress memleak
 }
@@ -15828,7 +14460,7 @@ void test__clogf__useretval() {
 }
 
 void test__clogf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = clogf(p);
   // cppcheck-suppress memleak
 }
@@ -15852,7 +14484,7 @@ void test__clogl__useretval() {
 }
 
 void test__clogl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = clogl(p);
   // cppcheck-suppress memleak
 }
@@ -15876,7 +14508,7 @@ void test__conj__useretval() {
 }
 
 void test__conj__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = conj(p);
   // cppcheck-suppress memleak
 }
@@ -15900,7 +14532,7 @@ void test__conjf__useretval() {
 }
 
 void test__conjf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = conjf(p);
   // cppcheck-suppress memleak
 }
@@ -15924,7 +14556,7 @@ void test__conjl__useretval() {
 }
 
 void test__conjl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = conjl(p);
   // cppcheck-suppress memleak
 }
@@ -15953,7 +14585,7 @@ void test__fpclassify__pure(int arg1) {
 }
 
 void test__fpclassify__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = fpclassify(p);
   // cppcheck-suppress memleak
 }
@@ -15981,12 +14613,6 @@ void test__std__fpclassify__pure(int arg1) {
   if ((std::fpclassify(arg1) > 10) || (std::fpclassify(arg1) < 100)) {}
 }
 
-void test__std__fpclassify__leakignore() {
-  char *p = strdup(str);
-  result = std::fpclassify(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fpclassify__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16011,7 +14637,7 @@ void test__isfinite__pure(int arg1) {
 }
 
 void test__isfinite__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isfinite(p);
   // cppcheck-suppress memleak
 }
@@ -16039,12 +14665,6 @@ void test__std__isfinite__pure(int arg1) {
   if ((std::isfinite(arg1) > 10) || (std::isfinite(arg1) < 100)) {}
 }
 
-void test__std__isfinite__leakignore() {
-  char *p = strdup(str);
-  result = std::isfinite(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isfinite__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16069,7 +14689,7 @@ void test__isgreater__pure(int arg1,int arg2) {
 }
 
 void test__isgreater__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isgreater(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -16103,12 +14723,6 @@ void test__std__isgreater__pure(int arg1,int arg2) {
   if ((std::isgreater(arg1, arg2) > 10) || (std::isgreater(arg1, arg2) < 100)) {}
 }
 
-void test__std__isgreater__leakignore() {
-  char *p = strdup(str);
-  result = std::isgreater(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isgreater__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16139,7 +14753,7 @@ void test__isgreaterequal__pure(int arg1,int arg2) {
 }
 
 void test__isgreaterequal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isgreaterequal(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -16173,12 +14787,6 @@ void test__std__isgreaterequal__pure(int arg1,int arg2) {
   if ((std::isgreaterequal(arg1, arg2) > 10) || (std::isgreaterequal(arg1, arg2) < 100)) {}
 }
 
-void test__std__isgreaterequal__leakignore() {
-  char *p = strdup(str);
-  result = std::isgreaterequal(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isgreaterequal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16209,7 +14817,7 @@ void test__isinf__pure(int arg1) {
 }
 
 void test__isinf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isinf(p);
   // cppcheck-suppress memleak
 }
@@ -16237,12 +14845,6 @@ void test__std__isinf__pure(int arg1) {
   if ((std::isinf(arg1) > 10) || (std::isinf(arg1) < 100)) {}
 }
 
-void test__std__isinf__leakignore() {
-  char *p = strdup(str);
-  result = std::isinf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isinf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16267,7 +14869,7 @@ void test__logb__pure(int arg1) {
 }
 
 void test__logb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = logb(p);
   // cppcheck-suppress memleak
 }
@@ -16295,12 +14897,6 @@ void test__std__logb__pure(int arg1) {
   if ((std::logb(arg1) > 10) || (std::logb(arg1) < 100)) {}
 }
 
-void test__std__logb__leakignore() {
-  char *p = strdup(str);
-  result = std::logb(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__logb__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16325,7 +14921,7 @@ void test__logbf__pure(int arg1) {
 }
 
 void test__logbf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = logbf(p);
   // cppcheck-suppress memleak
 }
@@ -16353,12 +14949,6 @@ void test__std__logbf__pure(int arg1) {
   if ((std::logbf(arg1) > 10) || (std::logbf(arg1) < 100)) {}
 }
 
-void test__std__logbf__leakignore() {
-  char *p = strdup(str);
-  result = std::logbf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__logbf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16383,7 +14973,7 @@ void test__logbl__pure(int arg1) {
 }
 
 void test__logbl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = logbl(p);
   // cppcheck-suppress memleak
 }
@@ -16411,12 +15001,6 @@ void test__std__logbl__pure(int arg1) {
   if ((std::logbl(arg1) > 10) || (std::logbl(arg1) < 100)) {}
 }
 
-void test__std__logbl__leakignore() {
-  char *p = strdup(str);
-  result = std::logbl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__logbl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16441,7 +15025,7 @@ void test__isless__pure(int arg1,int arg2) {
 }
 
 void test__isless__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isless(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -16475,12 +15059,6 @@ void test__std__isless__pure(int arg1,int arg2) {
   if ((std::isless(arg1, arg2) > 10) || (std::isless(arg1, arg2) < 100)) {}
 }
 
-void test__std__isless__leakignore() {
-  char *p = strdup(str);
-  result = std::isless(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isless__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16511,7 +15089,7 @@ void test__islessequal__pure(int arg1,int arg2) {
 }
 
 void test__islessequal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = islessequal(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -16545,12 +15123,6 @@ void test__std__islessequal__pure(int arg1,int arg2) {
   if ((std::islessequal(arg1, arg2) > 10) || (std::islessequal(arg1, arg2) < 100)) {}
 }
 
-void test__std__islessequal__leakignore() {
-  char *p = strdup(str);
-  result = std::islessequal(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__islessequal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16581,7 +15153,7 @@ void test__islessgreater__pure(int arg1,int arg2) {
 }
 
 void test__islessgreater__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = islessgreater(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -16615,12 +15187,6 @@ void test__std__islessgreater__pure(int arg1,int arg2) {
   if ((std::islessgreater(arg1, arg2) > 10) || (std::islessgreater(arg1, arg2) < 100)) {}
 }
 
-void test__std__islessgreater__leakignore() {
-  char *p = strdup(str);
-  result = std::islessgreater(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__islessgreater__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16651,7 +15217,7 @@ void test__nan__pure(int arg1) {
 }
 
 void test__nan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nan(p);
   // cppcheck-suppress memleak
 }
@@ -16685,12 +15251,6 @@ void test__std__nan__pure(int arg1) {
   if ((std::nan(arg1) > 10) || (std::nan(arg1) < 100)) {}
 }
 
-void test__std__nan__leakignore() {
-  char *p = strdup(str);
-  result = std::nan(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nan__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -16721,7 +15281,7 @@ void test__nanf__pure(int arg1) {
 }
 
 void test__nanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nanf(p);
   // cppcheck-suppress memleak
 }
@@ -16755,12 +15315,6 @@ void test__std__nanf__pure(int arg1) {
   if ((std::nanf(arg1) > 10) || (std::nanf(arg1) < 100)) {}
 }
 
-void test__std__nanf__leakignore() {
-  char *p = strdup(str);
-  result = std::nanf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -16791,7 +15345,7 @@ void test__nanl__pure(int arg1) {
 }
 
 void test__nanl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nanl(p);
   // cppcheck-suppress memleak
 }
@@ -16825,12 +15379,6 @@ void test__std__nanl__pure(int arg1) {
   if ((std::nanl(arg1) > 10) || (std::nanl(arg1) < 100)) {}
 }
 
-void test__std__nanl__leakignore() {
-  char *p = strdup(str);
-  result = std::nanl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nanl__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -16861,7 +15409,7 @@ void test__isnan__pure(int arg1) {
 }
 
 void test__isnan__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isnan(p);
   // cppcheck-suppress memleak
 }
@@ -16889,12 +15437,6 @@ void test__std__isnan__pure(int arg1) {
   if ((std::isnan(arg1) > 10) || (std::isnan(arg1) < 100)) {}
 }
 
-void test__std__isnan__leakignore() {
-  char *p = strdup(str);
-  result = std::isnan(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isnan__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16919,7 +15461,7 @@ void test__isnormal__pure(int arg1) {
 }
 
 void test__isnormal__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isnormal(p);
   // cppcheck-suppress memleak
 }
@@ -16947,12 +15489,6 @@ void test__std__isnormal__pure(int arg1) {
   if ((std::isnormal(arg1) > 10) || (std::isnormal(arg1) < 100)) {}
 }
 
-void test__std__isnormal__leakignore() {
-  char *p = strdup(str);
-  result = std::isnormal(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isnormal__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -16977,7 +15513,7 @@ void test__isunordered__pure(int arg1,int arg2) {
 }
 
 void test__isunordered__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = isunordered(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -17011,12 +15547,6 @@ void test__std__isunordered__pure(int arg1,int arg2) {
   if ((std::isunordered(arg1, arg2) > 10) || (std::isunordered(arg1, arg2) < 100)) {}
 }
 
-void test__std__isunordered__leakignore() {
-  char *p = strdup(str);
-  result = std::isunordered(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__isunordered__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17047,7 +15577,7 @@ void test__ilogb__pure(int arg1) {
 }
 
 void test__ilogb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ilogb(p);
   // cppcheck-suppress memleak
 }
@@ -17075,12 +15605,6 @@ void test__std__ilogb__pure(int arg1) {
   if ((std::ilogb(arg1) > 10) || (std::ilogb(arg1) < 100)) {}
 }
 
-void test__std__ilogb__leakignore() {
-  char *p = strdup(str);
-  result = std::ilogb(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ilogb__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17105,7 +15629,7 @@ void test__ilogbf__pure(int arg1) {
 }
 
 void test__ilogbf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ilogbf(p);
   // cppcheck-suppress memleak
 }
@@ -17133,12 +15657,6 @@ void test__std__ilogbf__pure(int arg1) {
   if ((std::ilogbf(arg1) > 10) || (std::ilogbf(arg1) < 100)) {}
 }
 
-void test__std__ilogbf__leakignore() {
-  char *p = strdup(str);
-  result = std::ilogbf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ilogbf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17163,7 +15681,7 @@ void test__ilogbl__pure(int arg1) {
 }
 
 void test__ilogbl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ilogbl(p);
   // cppcheck-suppress memleak
 }
@@ -17191,12 +15709,6 @@ void test__std__ilogbl__pure(int arg1) {
   if ((std::ilogbl(arg1) > 10) || (std::ilogbl(arg1) < 100)) {}
 }
 
-void test__std__ilogbl__leakignore() {
-  char *p = strdup(str);
-  result = std::ilogbl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ilogbl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17221,7 +15733,7 @@ void test__log10__pure(int arg1) {
 }
 
 void test__log10__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log10(p);
   // cppcheck-suppress memleak
 }
@@ -17249,12 +15761,6 @@ void test__std__log10__pure(int arg1) {
   if ((std::log10(arg1) > 10) || (std::log10(arg1) < 100)) {}
 }
 
-void test__std__log10__leakignore() {
-  char *p = strdup(str);
-  result = std::log10(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log10__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17279,7 +15785,7 @@ void test__log10f__pure(int arg1) {
 }
 
 void test__log10f__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log10f(p);
   // cppcheck-suppress memleak
 }
@@ -17307,12 +15813,6 @@ void test__std__log10f__pure(int arg1) {
   if ((std::log10f(arg1) > 10) || (std::log10f(arg1) < 100)) {}
 }
 
-void test__std__log10f__leakignore() {
-  char *p = strdup(str);
-  result = std::log10f(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log10f__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17337,7 +15837,7 @@ void test__log10l__pure(int arg1) {
 }
 
 void test__log10l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log10l(p);
   // cppcheck-suppress memleak
 }
@@ -17365,12 +15865,6 @@ void test__std__log10l__pure(int arg1) {
   if ((std::log10l(arg1) > 10) || (std::log10l(arg1) < 100)) {}
 }
 
-void test__std__log10l__leakignore() {
-  char *p = strdup(str);
-  result = std::log10l(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log10l__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17395,7 +15889,7 @@ void test__log1p__pure(int arg1) {
 }
 
 void test__log1p__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log1p(p);
   // cppcheck-suppress memleak
 }
@@ -17423,12 +15917,6 @@ void test__std__log1p__pure(int arg1) {
   if ((std::log1p(arg1) > 10) || (std::log1p(arg1) < 100)) {}
 }
 
-void test__std__log1p__leakignore() {
-  char *p = strdup(str);
-  result = std::log1p(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log1p__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17453,7 +15941,7 @@ void test__log1pf__pure(int arg1) {
 }
 
 void test__log1pf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log1pf(p);
   // cppcheck-suppress memleak
 }
@@ -17481,12 +15969,6 @@ void test__std__log1pf__pure(int arg1) {
   if ((std::log1pf(arg1) > 10) || (std::log1pf(arg1) < 100)) {}
 }
 
-void test__std__log1pf__leakignore() {
-  char *p = strdup(str);
-  result = std::log1pf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log1pf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17511,7 +15993,7 @@ void test__log1pl__pure(int arg1) {
 }
 
 void test__log1pl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log1pl(p);
   // cppcheck-suppress memleak
 }
@@ -17539,12 +16021,6 @@ void test__std__log1pl__pure(int arg1) {
   if ((std::log1pl(arg1) > 10) || (std::log1pl(arg1) < 100)) {}
 }
 
-void test__std__log1pl__leakignore() {
-  char *p = strdup(str);
-  result = std::log1pl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log1pl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17569,7 +16045,7 @@ void test__log2__pure(int arg1) {
 }
 
 void test__log2__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log2(p);
   // cppcheck-suppress memleak
 }
@@ -17597,12 +16073,6 @@ void test__std__log2__pure(int arg1) {
   if ((std::log2(arg1) > 10) || (std::log2(arg1) < 100)) {}
 }
 
-void test__std__log2__leakignore() {
-  char *p = strdup(str);
-  result = std::log2(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log2__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17627,7 +16097,7 @@ void test__log2f__pure(int arg1) {
 }
 
 void test__log2f__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log2f(p);
   // cppcheck-suppress memleak
 }
@@ -17655,12 +16125,6 @@ void test__std__log2f__pure(int arg1) {
   if ((std::log2f(arg1) > 10) || (std::log2f(arg1) < 100)) {}
 }
 
-void test__std__log2f__leakignore() {
-  char *p = strdup(str);
-  result = std::log2f(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log2f__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17685,7 +16149,7 @@ void test__log2l__pure(int arg1) {
 }
 
 void test__log2l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = log2l(p);
   // cppcheck-suppress memleak
 }
@@ -17713,12 +16177,6 @@ void test__std__log2l__pure(int arg1) {
   if ((std::log2l(arg1) > 10) || (std::log2l(arg1) < 100)) {}
 }
 
-void test__std__log2l__leakignore() {
-  char *p = strdup(str);
-  result = std::log2l(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__log2l__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17743,7 +16201,7 @@ void test__nearbyint__pure(int arg1) {
 }
 
 void test__nearbyint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nearbyint(p);
   // cppcheck-suppress memleak
 }
@@ -17771,12 +16229,6 @@ void test__std__nearbyint__pure(int arg1) {
   if ((std::nearbyint(arg1) > 10) || (std::nearbyint(arg1) < 100)) {}
 }
 
-void test__std__nearbyint__leakignore() {
-  char *p = strdup(str);
-  result = std::nearbyint(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nearbyint__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17801,7 +16253,7 @@ void test__nearbyintf__pure(int arg1) {
 }
 
 void test__nearbyintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nearbyintf(p);
   // cppcheck-suppress memleak
 }
@@ -17829,12 +16281,6 @@ void test__std__nearbyintf__pure(int arg1) {
   if ((std::nearbyintf(arg1) > 10) || (std::nearbyintf(arg1) < 100)) {}
 }
 
-void test__std__nearbyintf__leakignore() {
-  char *p = strdup(str);
-  result = std::nearbyintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nearbyintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17859,7 +16305,7 @@ void test__nearbyintl__pure(int arg1) {
 }
 
 void test__nearbyintl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nearbyintl(p);
   // cppcheck-suppress memleak
 }
@@ -17887,12 +16333,6 @@ void test__std__nearbyintl__pure(int arg1) {
   if ((std::nearbyintl(arg1) > 10) || (std::nearbyintl(arg1) < 100)) {}
 }
 
-void test__std__nearbyintl__leakignore() {
-  char *p = strdup(str);
-  result = std::nearbyintl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nearbyintl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17917,7 +16357,7 @@ void test__nextafter__pure(int arg1,int arg2) {
 }
 
 void test__nextafter__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nextafter(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -17951,12 +16391,6 @@ void test__std__nextafter__pure(int arg1,int arg2) {
   if ((std::nextafter(arg1, arg2) > 10) || (std::nextafter(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafter__leakignore() {
-  char *p = strdup(str);
-  result = std::nextafter(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nextafter__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -17987,7 +16421,7 @@ void test__nextafterf__pure(int arg1,int arg2) {
 }
 
 void test__nextafterf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nextafterf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18021,12 +16455,6 @@ void test__std__nextafterf__pure(int arg1,int arg2) {
   if ((std::nextafterf(arg1, arg2) > 10) || (std::nextafterf(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafterf__leakignore() {
-  char *p = strdup(str);
-  result = std::nextafterf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nextafterf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18057,7 +16485,7 @@ void test__nextafterl__pure(int arg1,int arg2) {
 }
 
 void test__nextafterl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nextafterl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18091,12 +16519,6 @@ void test__std__nextafterl__pure(int arg1,int arg2) {
   if ((std::nextafterl(arg1, arg2) > 10) || (std::nextafterl(arg1, arg2) < 100)) {}
 }
 
-void test__std__nextafterl__leakignore() {
-  char *p = strdup(str);
-  result = std::nextafterl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nextafterl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18127,7 +16549,7 @@ void test__nexttoward__pure(int arg1,int arg2) {
 }
 
 void test__nexttoward__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nexttoward(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18161,12 +16583,6 @@ void test__std__nexttoward__pure(int arg1,int arg2) {
   if ((std::nexttoward(arg1, arg2) > 10) || (std::nexttoward(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttoward__leakignore() {
-  char *p = strdup(str);
-  result = std::nexttoward(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nexttoward__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18197,7 +16613,7 @@ void test__nexttowardf__pure(int arg1,int arg2) {
 }
 
 void test__nexttowardf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nexttowardf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18231,12 +16647,6 @@ void test__std__nexttowardf__pure(int arg1,int arg2) {
   if ((std::nexttowardf(arg1, arg2) > 10) || (std::nexttowardf(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttowardf__leakignore() {
-  char *p = strdup(str);
-  result = std::nexttowardf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nexttowardf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18267,7 +16677,7 @@ void test__nexttowardl__pure(int arg1,int arg2) {
 }
 
 void test__nexttowardl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = nexttowardl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18301,12 +16711,6 @@ void test__std__nexttowardl__pure(int arg1,int arg2) {
   if ((std::nexttowardl(arg1, arg2) > 10) || (std::nexttowardl(arg1, arg2) < 100)) {}
 }
 
-void test__std__nexttowardl__leakignore() {
-  char *p = strdup(str);
-  result = std::nexttowardl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__nexttowardl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18327,7 +16731,7 @@ void test__longjmp__noreturn() {
 }
 
 void test__longjmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   longjmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -18351,12 +16755,6 @@ void test__std__longjmp__noreturn() {
   x = 1 << x;
 }
 
-void test__std__longjmp__leakignore() {
-  char *p = strdup(str);
-  std::longjmp(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__longjmp__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -18441,7 +16839,7 @@ void test__memchr__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__memchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = memchr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -18497,12 +16895,6 @@ void test__std__memchr__pure(int arg1,int arg2,int arg3) {
   if ((std::memchr(arg1, arg2, arg3) > 10) || (std::memchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__memchr__leakignore() {
-  char *p = strdup(str);
-  result = std::memchr(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__memchr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -18555,7 +16947,7 @@ void test__wmemchr__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__wmemchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wmemchr(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -18611,12 +17003,6 @@ void test__std__wmemchr__pure(int arg1,int arg2,int arg3) {
   if ((std::wmemchr(arg1, arg2, arg3) > 10) || (std::wmemchr(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__wmemchr__leakignore() {
-  char *p = strdup(str);
-  result = std::wmemchr(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wmemchr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -18669,7 +17055,7 @@ void test__memcmp__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__memcmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = memcmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -18726,12 +17112,6 @@ void test__std__memcmp__pure(int arg1,int arg2,int arg3) {
   if ((std::memcmp(arg1, arg2, arg3) > 10) || (std::memcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__memcmp__leakignore() {
-  char *p = strdup(str);
-  result = std::memcmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__memcmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -18785,7 +17165,7 @@ void test__wmemcmp__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__wmemcmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wmemcmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -18842,12 +17222,6 @@ void test__std__wmemcmp__pure(int arg1,int arg2,int arg3) {
   if ((std::wmemcmp(arg1, arg2, arg3) > 10) || (std::wmemcmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__wmemcmp__leakignore() {
-  char *p = strdup(str);
-  result = std::wmemcmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wmemcmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -18891,7 +17265,7 @@ void test__memcpy__noreturn() {
 }
 
 void test__memcpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memcpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -18932,12 +17306,6 @@ void test__std__memcpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__memcpy__leakignore() {
-  char *p = strdup(str);
-  std::memcpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__memcpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -18975,7 +17343,7 @@ void test__wmemcpy__noreturn() {
 }
 
 void test__wmemcpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wmemcpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -19016,12 +17384,6 @@ void test__std__wmemcpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wmemcpy__leakignore() {
-  char *p = strdup(str);
-  std::wmemcpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wmemcpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19059,7 +17421,7 @@ void test__memcpy_s__noreturn() {
 }
 
 void test__memcpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memcpy_s(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -19112,7 +17474,7 @@ void test__wmemcpy_s__noreturn() {
 }
 
 void test__wmemcpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wmemcpy_s(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -19165,7 +17527,7 @@ void test__memmove__noreturn() {
 }
 
 void test__memmove__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memmove(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -19206,12 +17568,6 @@ void test__std__memmove__noreturn() {
   x = 1 << x;
 }
 
-void test__std__memmove__leakignore() {
-  char *p = strdup(str);
-  std::memmove(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__memmove__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19249,7 +17605,7 @@ void test__wmemmove__noreturn() {
 }
 
 void test__wmemmove__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wmemmove(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -19290,12 +17646,6 @@ void test__std__wmemmove__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wmemmove__leakignore() {
-  char *p = strdup(str);
-  std::wmemmove(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wmemmove__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19333,7 +17683,7 @@ void test__memset_s__noreturn() {
 }
 
 void test__memset_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memset_s(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -19370,7 +17720,7 @@ void test__memset__noreturn() {
 }
 
 void test__memset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   memset(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -19405,12 +17755,6 @@ void test__std__memset__noreturn() {
   x = 1 << x;
 }
 
-void test__std__memset__leakignore() {
-  char *p = strdup(str);
-  std::memset(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__memset__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19442,7 +17786,7 @@ void test__wmemset__noreturn() {
 }
 
 void test__wmemset__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wmemset(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -19477,12 +17821,6 @@ void test__std__wmemset__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wmemset__leakignore() {
-  char *p = strdup(str);
-  std::wmemset(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wmemset__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19514,7 +17852,7 @@ void test__mktime__noreturn() {
 }
 
 void test__mktime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mktime(p);
   // cppcheck-suppress memleak
 }
@@ -19538,12 +17876,6 @@ void test__std__mktime__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mktime__leakignore() {
-  char *p = strdup(str);
-  std::mktime(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mktime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -19564,7 +17896,7 @@ void test__mkxtime__noreturn() {
 }
 
 void test__mkxtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mkxtime(p);
   // cppcheck-suppress memleak
 }
@@ -19589,7 +17921,7 @@ void test__modf__noreturn() {
 }
 
 void test__modf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   modf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19613,12 +17945,6 @@ void test__std__modf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__modf__leakignore() {
-  char *p = strdup(str);
-  std::modf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__modf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19639,7 +17965,7 @@ void test__modff__noreturn() {
 }
 
 void test__modff__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   modff(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19663,12 +17989,6 @@ void test__std__modff__noreturn() {
   x = 1 << x;
 }
 
-void test__std__modff__leakignore() {
-  char *p = strdup(str);
-  std::modff(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__modff__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19689,7 +18009,7 @@ void test__modfl__noreturn() {
 }
 
 void test__modfl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   modfl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19713,12 +18033,6 @@ void test__std__modfl__noreturn() {
   x = 1 << x;
 }
 
-void test__std__modfl__leakignore() {
-  char *p = strdup(str);
-  std::modfl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__modfl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19739,7 +18053,7 @@ void test__perror__noreturn() {
 }
 
 void test__perror__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   perror(p);
   // cppcheck-suppress memleak
 }
@@ -19757,12 +18071,6 @@ void test__std__perror__noreturn() {
   x = 1 << x;
 }
 
-void test__std__perror__leakignore() {
-  char *p = strdup(str);
-  std::perror(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__perror__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19787,7 +18095,7 @@ void test__pow__pure(int arg1,int arg2) {
 }
 
 void test__pow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = pow(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19821,12 +18129,6 @@ void test__std__pow__pure(int arg1,int arg2) {
   if ((std::pow(arg1, arg2) > 10) || (std::pow(arg1, arg2) < 100)) {}
 }
 
-void test__std__pow__leakignore() {
-  char *p = strdup(str);
-  result = std::pow(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__pow__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19857,7 +18159,7 @@ void test__powf__pure(int arg1,int arg2) {
 }
 
 void test__powf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = powf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19891,12 +18193,6 @@ void test__std__powf__pure(int arg1,int arg2) {
   if ((std::powf(arg1, arg2) > 10) || (std::powf(arg1, arg2) < 100)) {}
 }
 
-void test__std__powf__leakignore() {
-  char *p = strdup(str);
-  result = std::powf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__powf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19927,7 +18223,7 @@ void test__powl__pure(int arg1,int arg2) {
 }
 
 void test__powl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = powl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -19961,12 +18257,6 @@ void test__std__powl__pure(int arg1,int arg2) {
   if ((std::powl(arg1, arg2) > 10) || (std::powl(arg1, arg2) < 100)) {}
 }
 
-void test__std__powl__leakignore() {
-  char *p = strdup(str);
-  result = std::powl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__powl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -19997,7 +18287,7 @@ void test__cpow__pure(int arg1,int arg2) {
 }
 
 void test__cpow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cpow(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20032,7 +18322,7 @@ void test__cpowf__pure(int arg1,int arg2) {
 }
 
 void test__cpowf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cpowf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20067,7 +18357,7 @@ void test__cpowl__pure(int arg1,int arg2) {
 }
 
 void test__cpowl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = cpowl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20102,7 +18392,7 @@ void test__remainder__pure(int arg1,int arg2) {
 }
 
 void test__remainder__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remainder(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20136,12 +18426,6 @@ void test__std__remainder__pure(int arg1,int arg2) {
   if ((std::remainder(arg1, arg2) > 10) || (std::remainder(arg1, arg2) < 100)) {}
 }
 
-void test__std__remainder__leakignore() {
-  char *p = strdup(str);
-  result = std::remainder(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remainder__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20172,7 +18456,7 @@ void test__remainderf__pure(int arg1,int arg2) {
 }
 
 void test__remainderf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remainderf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20206,12 +18490,6 @@ void test__std__remainderf__pure(int arg1,int arg2) {
   if ((std::remainderf(arg1, arg2) > 10) || (std::remainderf(arg1, arg2) < 100)) {}
 }
 
-void test__std__remainderf__leakignore() {
-  char *p = strdup(str);
-  result = std::remainderf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remainderf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20242,7 +18520,7 @@ void test__remainderl__pure(int arg1,int arg2) {
 }
 
 void test__remainderl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remainderl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20276,12 +18554,6 @@ void test__std__remainderl__pure(int arg1,int arg2) {
   if ((std::remainderl(arg1, arg2) > 10) || (std::remainderl(arg1, arg2) < 100)) {}
 }
 
-void test__std__remainderl__leakignore() {
-  char *p = strdup(str);
-  result = std::remainderl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remainderl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20312,7 +18584,7 @@ void test__remquo__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__remquo__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remquo(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -20352,12 +18624,6 @@ void test__std__remquo__pure(int arg1,int arg2,int arg3) {
   if ((std::remquo(arg1, arg2, arg3) > 10) || (std::remquo(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__remquo__leakignore() {
-  char *p = strdup(str);
-  result = std::remquo(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remquo__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20394,7 +18660,7 @@ void test__remquof__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__remquof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remquof(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -20434,12 +18700,6 @@ void test__std__remquof__pure(int arg1,int arg2,int arg3) {
   if ((std::remquof(arg1, arg2, arg3) > 10) || (std::remquof(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__remquof__leakignore() {
-  char *p = strdup(str);
-  result = std::remquof(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remquof__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20476,7 +18736,7 @@ void test__remquol__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__remquol__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = remquol(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -20516,12 +18776,6 @@ void test__std__remquol__pure(int arg1,int arg2,int arg3) {
   if ((std::remquol(arg1, arg2, arg3) > 10) || (std::remquol(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__remquol__leakignore() {
-  char *p = strdup(str);
-  result = std::remquol(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remquol__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20548,7 +18802,7 @@ void test__printf__noreturn() {
 }
 
 void test__printf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   printf(p);
   // cppcheck-suppress memleak
 }
@@ -20566,12 +18820,6 @@ void test__std__printf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__printf__leakignore() {
-  char *p = strdup(str);
-  std::printf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__printf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20586,7 +18834,7 @@ void test__vprintf__noreturn() {
 }
 
 void test__vprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20604,12 +18852,6 @@ void test__std__vprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vprintf__leakignore() {
-  char *p = strdup(str);
-  std::vprintf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20624,7 +18866,7 @@ void test__vwprintf__noreturn() {
 }
 
 void test__vwprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vwprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20642,12 +18884,6 @@ void test__std__vwprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vwprintf__leakignore() {
-  char *p = strdup(str);
-  std::vwprintf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vwprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -20672,7 +18908,7 @@ void test__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5) {
 }
 
 void test__bsearch__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = bsearch(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -20742,12 +18978,6 @@ void test__std__bsearch__pure(int arg1,int arg2,int arg3,int arg4,int arg5) {
   if ((std::bsearch(arg1, arg2, arg3, arg4, arg5) > 10) || (std::bsearch(arg1, arg2, arg3, arg4, arg5) < 100)) {}
 }
 
-void test__std__bsearch__leakignore() {
-  char *p = strdup(str);
-  result = std::bsearch(p, arg2, arg3, arg4, arg5);
-  // cppcheck-suppress memleak
-}
-
 void test__std__bsearch__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -20804,7 +19034,7 @@ void test__qsort__noreturn() {
 }
 
 void test__qsort__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   qsort(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -20852,12 +19082,6 @@ void test__std__qsort__noreturn() {
   x = 1 << x;
 }
 
-void test__std__qsort__leakignore() {
-  char *p = strdup(str);
-  std::qsort(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__qsort__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -20902,7 +19126,7 @@ void test__putc__noreturn() {
 }
 
 void test__putc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   putc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -20937,12 +19161,6 @@ void test__std__putc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__putc__leakignore() {
-  char *p = strdup(str);
-  std::putc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__putc__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   std::putc(!x, arg2);
@@ -20974,7 +19192,7 @@ void test__putwc__noreturn() {
 }
 
 void test__putwc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   putwc(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21004,12 +19222,6 @@ void test__std__putwc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__putwc__leakignore() {
-  char *p = strdup(str);
-  std::putwc(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__putwc__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21036,7 +19248,7 @@ void test__putchar__noreturn() {
 }
 
 void test__putchar__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   putchar(p);
   // cppcheck-suppress memleak
 }
@@ -21059,12 +19271,6 @@ void test__std__putchar__noreturn() {
   x = 1 << x;
 }
 
-void test__std__putchar__leakignore() {
-  char *p = strdup(str);
-  std::putchar(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__putchar__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   std::putchar(!x);
@@ -21084,7 +19290,7 @@ void test__putwchar__noreturn() {
 }
 
 void test__putwchar__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   putwchar(p);
   // cppcheck-suppress memleak
 }
@@ -21102,12 +19308,6 @@ void test__std__putwchar__noreturn() {
   x = 1 << x;
 }
 
-void test__std__putwchar__leakignore() {
-  char *p = strdup(str);
-  std::putwchar(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__putwchar__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21122,7 +19322,7 @@ void test__puts__noreturn() {
 }
 
 void test__puts__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   puts(p);
   // cppcheck-suppress memleak
 }
@@ -21151,12 +19351,6 @@ void test__std__puts__noreturn() {
   x = 1 << x;
 }
 
-void test__std__puts__leakignore() {
-  char *p = strdup(str);
-  std::puts(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__puts__arg1__notbool() {
   // cppcheck-suppress invalidFunctionArgBool
   std::puts(!x);
@@ -21220,7 +19414,7 @@ void test__remove__noreturn() {
 }
 
 void test__remove__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   remove(p);
   // cppcheck-suppress memleak
 }
@@ -21244,12 +19438,6 @@ void test__std__remove__noreturn() {
   x = 1 << x;
 }
 
-void test__std__remove__leakignore() {
-  char *p = strdup(str);
-  std::remove(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__remove__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -21270,7 +19458,7 @@ void test__rename__noreturn() {
 }
 
 void test__rename__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rename(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21306,12 +19494,6 @@ void test__std__rename__noreturn() {
   x = 1 << x;
 }
 
-void test__std__rename__leakignore() {
-  char *p = strdup(str);
-  std::rename(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__rename__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -21344,7 +19526,7 @@ void test__rewind__noreturn() {
 }
 
 void test__rewind__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   rewind(p);
   // cppcheck-suppress memleak
 }
@@ -21368,12 +19550,6 @@ void test__std__rewind__noreturn() {
   x = 1 << x;
 }
 
-void test__std__rewind__leakignore() {
-  char *p = strdup(str);
-  std::rewind(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__rewind__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -21404,7 +19580,7 @@ void test__round__pure(int arg1) {
 }
 
 void test__round__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = round(p);
   // cppcheck-suppress memleak
 }
@@ -21432,12 +19608,6 @@ void test__std__round__pure(int arg1) {
   if ((std::round(arg1) > 10) || (std::round(arg1) < 100)) {}
 }
 
-void test__std__round__leakignore() {
-  char *p = strdup(str);
-  result = std::round(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__round__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21462,7 +19632,7 @@ void test__roundf__pure(int arg1) {
 }
 
 void test__roundf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = roundf(p);
   // cppcheck-suppress memleak
 }
@@ -21490,12 +19660,6 @@ void test__std__roundf__pure(int arg1) {
   if ((std::roundf(arg1) > 10) || (std::roundf(arg1) < 100)) {}
 }
 
-void test__std__roundf__leakignore() {
-  char *p = strdup(str);
-  result = std::roundf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__roundf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21520,7 +19684,7 @@ void test__roundl__pure(int arg1) {
 }
 
 void test__roundl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = roundl(p);
   // cppcheck-suppress memleak
 }
@@ -21548,12 +19712,6 @@ void test__std__roundl__pure(int arg1) {
   if ((std::roundl(arg1) > 10) || (std::roundl(arg1) < 100)) {}
 }
 
-void test__std__roundl__leakignore() {
-  char *p = strdup(str);
-  result = std::roundl(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__roundl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21578,7 +19736,7 @@ void test__scalbn__pure(int arg1,int arg2) {
 }
 
 void test__scalbn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalbn(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21612,12 +19770,6 @@ void test__std__scalbn__pure(int arg1,int arg2) {
   if ((std::scalbn(arg1, arg2) > 10) || (std::scalbn(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalbn__leakignore() {
-  char *p = strdup(str);
-  result = std::scalbn(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalbn__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21648,7 +19800,7 @@ void test__scalbnf__pure(int arg1,int arg2) {
 }
 
 void test__scalbnf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalbnf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21682,12 +19834,6 @@ void test__std__scalbnf__pure(int arg1,int arg2) {
   if ((std::scalbnf(arg1, arg2) > 10) || (std::scalbnf(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalbnf__leakignore() {
-  char *p = strdup(str);
-  result = std::scalbnf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalbnf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21718,7 +19864,7 @@ void test__scalbnl__pure(int arg1,int arg2) {
 }
 
 void test__scalbnl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalbnl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21752,12 +19898,6 @@ void test__std__scalbnl__pure(int arg1,int arg2) {
   if ((std::scalbnl(arg1, arg2) > 10) || (std::scalbnl(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalbnl__leakignore() {
-  char *p = strdup(str);
-  result = std::scalbnl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalbnl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21788,7 +19928,7 @@ void test__scalbln__pure(int arg1,int arg2) {
 }
 
 void test__scalbln__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalbln(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21822,12 +19962,6 @@ void test__std__scalbln__pure(int arg1,int arg2) {
   if ((std::scalbln(arg1, arg2) > 10) || (std::scalbln(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalbln__leakignore() {
-  char *p = strdup(str);
-  result = std::scalbln(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalbln__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21858,7 +19992,7 @@ void test__scalblnf__pure(int arg1,int arg2) {
 }
 
 void test__scalblnf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalblnf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21892,12 +20026,6 @@ void test__std__scalblnf__pure(int arg1,int arg2) {
   if ((std::scalblnf(arg1, arg2) > 10) || (std::scalblnf(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalblnf__leakignore() {
-  char *p = strdup(str);
-  result = std::scalblnf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalblnf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21928,7 +20056,7 @@ void test__scalblnl__pure(int arg1,int arg2) {
 }
 
 void test__scalblnl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = scalblnl(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -21962,12 +20090,6 @@ void test__std__scalblnl__pure(int arg1,int arg2) {
   if ((std::scalblnl(arg1, arg2) > 10) || (std::scalblnl(arg1, arg2) < 100)) {}
 }
 
-void test__std__scalblnl__leakignore() {
-  char *p = strdup(str);
-  result = std::scalblnl(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scalblnl__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -21998,7 +20120,7 @@ void test__signbit__pure(int arg1) {
 }
 
 void test__signbit__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = signbit(p);
   // cppcheck-suppress memleak
 }
@@ -22026,12 +20148,6 @@ void test__std__signbit__pure(int arg1) {
   if ((std::signbit(arg1) > 10) || (std::signbit(arg1) < 100)) {}
 }
 
-void test__std__signbit__leakignore() {
-  char *p = strdup(str);
-  result = std::signbit(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__signbit__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -22098,7 +20214,7 @@ void test__scanf__noreturn() {
 }
 
 void test__scanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   scanf(p);
   // cppcheck-suppress memleak
 }
@@ -22122,12 +20238,6 @@ void test__std__scanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__scanf__leakignore() {
-  char *p = strdup(str);
-  std::scanf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__scanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22148,7 +20258,7 @@ void test__vsscanf__noreturn() {
 }
 
 void test__vsscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsscanf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -22184,12 +20294,6 @@ void test__std__vsscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vsscanf__leakignore() {
-  char *p = strdup(str);
-  std::vsscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vsscanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22222,7 +20326,7 @@ void test__vswscanf__noreturn() {
 }
 
 void test__vswscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vswscanf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -22258,12 +20362,6 @@ void test__std__vswscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vswscanf__leakignore() {
-  char *p = strdup(str);
-  std::vswscanf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vswscanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22296,7 +20394,7 @@ void test__vscanf__noreturn() {
 }
 
 void test__vscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22320,12 +20418,6 @@ void test__std__vscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vscanf__leakignore() {
-  char *p = strdup(str);
-  std::vscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vscanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22346,7 +20438,7 @@ void test__vwscanf__noreturn() {
 }
 
 void test__vwscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vwscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22364,12 +20456,6 @@ void test__std__vwscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vwscanf__leakignore() {
-  char *p = strdup(str);
-  std::vwscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vwscanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22384,7 +20470,7 @@ void test__setbuf__noreturn() {
 }
 
 void test__setbuf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setbuf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22413,12 +20499,6 @@ void test__std__setbuf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setbuf__leakignore() {
-  char *p = strdup(str);
-  std::setbuf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setbuf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22444,7 +20524,7 @@ void test__setvbuf__noreturn() {
 }
 
 void test__setvbuf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setvbuf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -22486,12 +20566,6 @@ void test__std__setvbuf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setvbuf__leakignore() {
-  char *p = strdup(str);
-  std::setvbuf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setvbuf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22530,7 +20604,7 @@ void test__setjmp__noreturn() {
 }
 
 void test__setjmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setjmp(p);
   // cppcheck-suppress memleak
 }
@@ -22543,7 +20617,7 @@ void test__strcat__noreturn() {
 }
 
 void test__strcat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strcat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22579,12 +20653,6 @@ void test__std__strcat__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strcat__leakignore() {
-  char *p = strdup(str);
-  std::strcat(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strcat__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22617,7 +20685,7 @@ void test__wcscat__noreturn() {
 }
 
 void test__wcscat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcscat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22647,12 +20715,6 @@ void test__std__wcscat__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcscat__leakignore() {
-  char *p = strdup(str);
-  std::wcscat(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcscat__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22679,7 +20741,7 @@ void test__wcrtomb__noreturn() {
 }
 
 void test__wcrtomb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcrtomb(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -22697,12 +20759,6 @@ void test__std__wcrtomb__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcrtomb__leakignore() {
-  char *p = strdup(str);
-  std::wcrtomb(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcrtomb__arg2__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -22722,7 +20778,7 @@ void test__strchr__useretval() {
 }
 
 void test__strchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22757,12 +20813,6 @@ void test__std__strchr__useretval() {
   std::strchr(arg1, arg2);
 }
 
-void test__std__strchr__leakignore() {
-  char *p = strdup(str);
-  result = std::strchr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strchr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22794,7 +20844,7 @@ void test__wcschr__useretval() {
 }
 
 void test__wcschr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcschr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22829,12 +20879,6 @@ void test__std__wcschr__useretval() {
   std::wcschr(arg1, arg2);
 }
 
-void test__std__wcschr__leakignore() {
-  char *p = strdup(str);
-  result = std::wcschr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcschr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22871,7 +20915,7 @@ void test__strcmp__pure(int arg1,int arg2) {
 }
 
 void test__strcmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strcmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -22917,12 +20961,6 @@ void test__std__strcmp__pure(int arg1,int arg2) {
   if ((std::strcmp(arg1, arg2) > 10) || (std::strcmp(arg1, arg2) < 100)) {}
 }
 
-void test__std__strcmp__leakignore() {
-  char *p = strdup(str);
-  result = std::strcmp(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strcmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -22965,7 +21003,7 @@ void test__wcscmp__pure(int arg1,int arg2) {
 }
 
 void test__wcscmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcscmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -23011,12 +21049,6 @@ void test__std__wcscmp__pure(int arg1,int arg2) {
   if ((std::wcscmp(arg1, arg2) > 10) || (std::wcscmp(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcscmp__leakignore() {
-  char *p = strdup(str);
-  result = std::wcscmp(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcscmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23049,7 +21081,7 @@ void test__strcpy__noreturn() {
 }
 
 void test__strcpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strcpy(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -23079,12 +21111,6 @@ void test__std__strcpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strcpy__leakignore() {
-  char *p = strdup(str);
-  std::strcpy(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strcpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23111,7 +21137,7 @@ void test__wcscpy__noreturn() {
 }
 
 void test__wcscpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcscpy(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -23141,12 +21167,6 @@ void test__std__wcscpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcscpy__leakignore() {
-  char *p = strdup(str);
-  std::wcscpy(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcscpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23173,7 +21193,7 @@ void test__strftime__noreturn() {
 }
 
 void test__strftime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strftime(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -23221,12 +21241,6 @@ void test__std__strftime__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strftime__leakignore() {
-  char *p = strdup(str);
-  std::strftime(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strftime__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23271,7 +21285,7 @@ void test__strfxtime__noreturn() {
 }
 
 void test__strfxtime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strfxtime(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -23330,7 +21344,7 @@ void test__strlen__pure(int arg1) {
 }
 
 void test__strlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strlen(p);
   // cppcheck-suppress memleak
 }
@@ -23364,12 +21378,6 @@ void test__std__strlen__pure(int arg1) {
   if ((std::strlen(arg1) > 10) || (std::strlen(arg1) < 100)) {}
 }
 
-void test__std__strlen__leakignore() {
-  char *p = strdup(str);
-  result = std::strlen(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strlen__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23400,7 +21408,7 @@ void test__wcslen__pure(int arg1) {
 }
 
 void test__wcslen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcslen(p);
   // cppcheck-suppress memleak
 }
@@ -23434,12 +21442,6 @@ void test__std__wcslen__pure(int arg1) {
   if ((std::wcslen(arg1) > 10) || (std::wcslen(arg1) < 100)) {}
 }
 
-void test__std__wcslen__leakignore() {
-  char *p = strdup(str);
-  result = std::wcslen(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcslen__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23460,7 +21462,7 @@ void test__strncpy__noreturn() {
 }
 
 void test__strncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -23501,12 +21503,6 @@ void test__std__strncpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strncpy__leakignore() {
-  char *p = strdup(str);
-  std::strncpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strncpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23549,7 +21545,7 @@ void test__strpbrk__useretval() {
 }
 
 void test__strpbrk__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strpbrk(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -23590,12 +21586,6 @@ void test__std__strpbrk__useretval() {
   std::strpbrk(arg1, arg2);
 }
 
-void test__std__strpbrk__leakignore() {
-  char *p = strdup(str);
-  result = std::strpbrk(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strpbrk__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23628,7 +21618,7 @@ void test__strncat__noreturn() {
 }
 
 void test__strncat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strncat(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -23675,12 +21665,6 @@ void test__std__strncat__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strncat__leakignore() {
-  char *p = strdup(str);
-  std::strncat(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strncat__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23724,7 +21708,7 @@ void test__wcsncat__noreturn() {
 }
 
 void test__wcsncat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsncat(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -23771,12 +21755,6 @@ void test__std__wcsncat__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcsncat__leakignore() {
-  char *p = strdup(str);
-  std::wcsncat(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsncat__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23830,7 +21808,7 @@ void test__strncmp__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__strncmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strncmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -23887,12 +21865,6 @@ void test__std__strncmp__pure(int arg1,int arg2,int arg3) {
   if ((std::strncmp(arg1, arg2, arg3) > 10) || (std::strncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__strncmp__leakignore() {
-  char *p = strdup(str);
-  result = std::strncmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strncmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -23946,7 +21918,7 @@ void test__wcsncmp__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__wcsncmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsncmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -24003,12 +21975,6 @@ void test__std__wcsncmp__pure(int arg1,int arg2,int arg3) {
   if ((std::wcsncmp(arg1, arg2, arg3) > 10) || (std::wcsncmp(arg1, arg2, arg3) < 100)) {}
 }
 
-void test__std__wcsncmp__leakignore() {
-  char *p = strdup(str);
-  result = std::wcsncmp(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsncmp__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24057,7 +22023,7 @@ void test__strstr__useretval() {
 }
 
 void test__strstr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strstr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24098,12 +22064,6 @@ void test__std__strstr__useretval() {
   std::strstr(arg1, arg2);
 }
 
-void test__std__strstr__leakignore() {
-  char *p = strdup(str);
-  result = std::strstr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strstr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24146,7 +22106,7 @@ void test__wcsstr__pure(int arg1,int arg2) {
 }
 
 void test__wcsstr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsstr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24192,12 +22152,6 @@ void test__std__wcsstr__pure(int arg1,int arg2) {
   if ((std::wcsstr(arg1, arg2) > 10) || (std::wcsstr(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcsstr__leakignore() {
-  char *p = strdup(str);
-  result = std::wcsstr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsstr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24235,7 +22189,7 @@ void test__strspn__useretval() {
 }
 
 void test__strspn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strspn(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24276,12 +22230,6 @@ void test__std__strspn__useretval() {
   std::strspn(arg1, arg2);
 }
 
-void test__std__strspn__leakignore() {
-  char *p = strdup(str);
-  result = std::strspn(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strspn__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24314,7 +22262,7 @@ void test__strxfrm__noreturn() {
 }
 
 void test__strxfrm__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strxfrm(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -24344,12 +22292,6 @@ void test__std__strxfrm__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strxfrm__leakignore() {
-  char *p = strdup(str);
-  std::strxfrm(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strxfrm__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24376,7 +22318,7 @@ void test__wcsxfrm__noreturn() {
 }
 
 void test__wcsxfrm__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsxfrm(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -24406,12 +22348,6 @@ void test__std__wcsxfrm__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcsxfrm__leakignore() {
-  char *p = strdup(str);
-  std::wcsxfrm(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsxfrm__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24448,7 +22384,7 @@ void test__wcsspn__pure(int arg1,int arg2) {
 }
 
 void test__wcsspn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsspn(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24494,12 +22430,6 @@ void test__std__wcsspn__pure(int arg1,int arg2) {
   if ((std::wcsspn(arg1, arg2) > 10) || (std::wcsspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcsspn__leakignore() {
-  char *p = strdup(str);
-  result = std::wcsspn(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsspn__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24537,7 +22467,7 @@ void test__localeconv__useretval() {
 }
 
 void test__localeconv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = localeconv();
   // cppcheck-suppress memleak
 }
@@ -24554,12 +22484,6 @@ void test__std__localeconv__useretval() {
   std::localeconv();
 }
 
-void test__std__localeconv__leakignore() {
-  char *p = strdup(str);
-  result = std::localeconv();
-  // cppcheck-suppress memleak
-}
-
 void test__std__locale__global__noreturn() {
   int x = 1;
   if (cond) { x=100; result = std::locale::global(arg1); }
@@ -24572,12 +22496,6 @@ void test__std__locale__global__useretval() {
   std::locale::global(arg1);
 }
 
-void test__std__locale__global__leakignore() {
-  char *p = strdup(str);
-  result = std::locale::global(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__locale__global__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -24596,12 +22514,6 @@ void test__std__locale__classic__useretval() {
   std::locale::classic();
 }
 
-void test__std__locale__classic__leakignore() {
-  char *p = strdup(str);
-  result = std::locale::classic();
-  // cppcheck-suppress memleak
-}
-
 void test__setlocale__noreturn() {
   int x = 1;
   if (cond) { x=100; setlocale(arg1, arg2); }
@@ -24610,7 +22522,7 @@ void test__setlocale__noreturn() {
 }
 
 void test__setlocale__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setlocale(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24634,12 +22546,6 @@ void test__std__setlocale__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setlocale__leakignore() {
-  char *p = strdup(str);
-  std::setlocale(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setlocale__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -24665,7 +22571,7 @@ void test__strerror__useretval() {
 }
 
 void test__strerror__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strerror(p);
   // cppcheck-suppress memleak
 }
@@ -24688,12 +22594,6 @@ void test__std__strerror__useretval() {
   std::strerror(arg1);
 }
 
-void test__std__strerror__leakignore() {
-  char *p = strdup(str);
-  result = std::strerror(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strerror__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -24718,7 +22618,7 @@ void test__strcspn__pure(int arg1,int arg2) {
 }
 
 void test__strcspn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strcspn(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24764,12 +22664,6 @@ void test__std__strcspn__pure(int arg1,int arg2) {
   if ((std::strcspn(arg1, arg2) > 10) || (std::strcspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__strcspn__leakignore() {
-  char *p = strdup(str);
-  result = std::strcspn(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strcspn__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24812,7 +22706,7 @@ void test__wcscspn__pure(int arg1,int arg2) {
 }
 
 void test__wcscspn__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcscspn(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24858,12 +22752,6 @@ void test__std__wcscspn__pure(int arg1,int arg2) {
   if ((std::wcscspn(arg1, arg2) > 10) || (std::wcscspn(arg1, arg2) < 100)) {}
 }
 
-void test__std__wcscspn__leakignore() {
-  char *p = strdup(str);
-  result = std::wcscspn(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcscspn__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24901,7 +22789,7 @@ void test__wcspbrk__useretval() {
 }
 
 void test__wcspbrk__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcspbrk(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -24936,12 +22824,6 @@ void test__std__wcspbrk__useretval() {
   std::wcspbrk(arg1, arg2);
 }
 
-void test__std__wcspbrk__leakignore() {
-  char *p = strdup(str);
-  result = std::wcspbrk(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcspbrk__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -24968,7 +22850,7 @@ void test__wcsncpy__noreturn() {
 }
 
 void test__wcsncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25009,12 +22891,6 @@ void test__std__wcsncpy__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcsncpy__leakignore() {
-  char *p = strdup(str);
-  std::wcsncpy(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsncpy__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25057,7 +22933,7 @@ void test__strcoll__useretval() {
 }
 
 void test__strcoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strcoll(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25098,12 +22974,6 @@ void test__std__strcoll__useretval() {
   std::strcoll(arg1, arg2);
 }
 
-void test__std__strcoll__leakignore() {
-  char *p = strdup(str);
-  result = std::strcoll(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strcoll__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25141,7 +23011,7 @@ void test__wcscoll__useretval() {
 }
 
 void test__wcscoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcscoll(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25182,12 +23052,6 @@ void test__std__wcscoll__useretval() {
   std::wcscoll(arg1, arg2);
 }
 
-void test__std__wcscoll__leakignore() {
-  char *p = strdup(str);
-  result = std::wcscoll(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcscoll__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25225,7 +23089,7 @@ void test__strrchr__useretval() {
 }
 
 void test__strrchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strrchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25260,12 +23124,6 @@ void test__std__strrchr__useretval() {
   std::strrchr(arg1, arg2);
 }
 
-void test__std__strrchr__leakignore() {
-  char *p = strdup(str);
-  result = std::strrchr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strrchr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25297,7 +23155,7 @@ void test__wcsrchr__useretval() {
 }
 
 void test__wcsrchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsrchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25332,12 +23190,6 @@ void test__std__wcsrchr__useretval() {
   std::wcsrchr(arg1, arg2);
 }
 
-void test__std__wcsrchr__leakignore() {
-  char *p = strdup(str);
-  result = std::wcsrchr(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsrchr__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25364,7 +23216,7 @@ void test__wcsrtombs__noreturn() {
 }
 
 void test__wcsrtombs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsrtombs(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -25400,12 +23252,6 @@ void test__std__wcsrtombs__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcsrtombs__leakignore() {
-  char *p = strdup(str);
-  std::wcsrtombs(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcsrtombs__arg2__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25443,7 +23289,7 @@ void test__strtok__pure(int arg1,int arg2) {
 }
 
 void test__strtok__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtok(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25478,12 +23324,6 @@ void test__std__strtok__pure(int arg1,int arg2) {
   if ((std::strtok(arg1, arg2) > 10) || (std::strtok(arg1, arg2) < 100)) {}
 }
 
-void test__std__strtok__leakignore() {
-  char *p = strdup(str);
-  std::strtok(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtok__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -25510,7 +23350,7 @@ void test__strtof__noreturn() {
 }
 
 void test__strtof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtof(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25534,12 +23374,6 @@ void test__std__strtof__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtof__leakignore() {
-  char *p = strdup(str);
-  std::strtof(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtof__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25560,7 +23394,7 @@ void test__strtod__noreturn() {
 }
 
 void test__strtod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25584,12 +23418,6 @@ void test__std__strtod__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtod__leakignore() {
-  char *p = strdup(str);
-  std::strtod(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtod__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25610,7 +23438,7 @@ void test__strtold__noreturn() {
 }
 
 void test__strtold__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtold(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -25634,12 +23462,6 @@ void test__std__strtold__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtold__leakignore() {
-  char *p = strdup(str);
-  std::strtold(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtold__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25660,7 +23482,7 @@ void test__strtol__noreturn() {
 }
 
 void test__strtol__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtol(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25690,12 +23512,6 @@ void test__std__strtol__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtol__leakignore() {
-  char *p = strdup(str);
-  std::strtol(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtol__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25722,7 +23538,7 @@ void test__strtoul__noreturn() {
 }
 
 void test__strtoul__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtoul(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25752,12 +23568,6 @@ void test__std__strtoul__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtoul__leakignore() {
-  char *p = strdup(str);
-  std::strtoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtoul__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25784,7 +23594,7 @@ void test__strtoll__noreturn() {
 }
 
 void test__strtoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtoll(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25814,12 +23624,6 @@ void test__std__strtoll__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtoll__leakignore() {
-  char *p = strdup(str);
-  std::strtoll(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtoll__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25846,7 +23650,7 @@ void test__strtoull__noreturn() {
 }
 
 void test__strtoull__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtoull(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25876,12 +23680,6 @@ void test__std__strtoull__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtoull__leakignore() {
-  char *p = strdup(str);
-  std::strtoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtoull__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25908,7 +23706,7 @@ void test__strtoimax__noreturn() {
 }
 
 void test__strtoimax__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtoimax(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -25938,12 +23736,6 @@ void test__std__strtoimax__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtoimax__leakignore() {
-  char *p = strdup(str);
-  std::strtoimax(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtoimax__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -25970,7 +23762,7 @@ void test__strtoumax__noreturn() {
 }
 
 void test__strtoumax__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtoumax(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26000,12 +23792,6 @@ void test__std__strtoumax__noreturn() {
   x = 1 << x;
 }
 
-void test__std__strtoumax__leakignore() {
-  char *p = strdup(str);
-  std::strtoumax(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__strtoumax__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -26032,7 +23818,7 @@ void test__time__noreturn() {
 }
 
 void test__time__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   time(p);
   // cppcheck-suppress memleak
 }
@@ -26050,12 +23836,6 @@ void test__std__time__noreturn() {
   x = 1 << x;
 }
 
-void test__std__time__leakignore() {
-  char *p = strdup(str);
-  std::time(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__time__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26070,7 +23850,7 @@ void test__tmpnam__noreturn() {
 }
 
 void test__tmpnam__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tmpnam(p);
   // cppcheck-suppress memleak
 }
@@ -26088,12 +23868,6 @@ void test__std__tmpnam__noreturn() {
   x = 1 << x;
 }
 
-void test__std__tmpnam__leakignore() {
-  char *p = strdup(str);
-  std::tmpnam(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tmpnam__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26108,7 +23882,7 @@ void test__tmpnam_s__noreturn() {
 }
 
 void test__tmpnam_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   tmpnam_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26150,7 +23924,7 @@ void test__tolower__useretval() {
 }
 
 void test__tolower__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = tolower(p);
   // cppcheck-suppress memleak
 }
@@ -26173,12 +23947,6 @@ void test__std__tolower__useretval() {
   std::tolower(arg1);
 }
 
-void test__std__tolower__leakignore() {
-  char *p = strdup(str);
-  result = std::tolower(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__tolower__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26198,7 +23966,7 @@ void test__toupper__useretval() {
 }
 
 void test__toupper__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = toupper(p);
   // cppcheck-suppress memleak
 }
@@ -26221,12 +23989,6 @@ void test__std__toupper__useretval() {
   std::toupper(arg1);
 }
 
-void test__std__toupper__leakignore() {
-  char *p = strdup(str);
-  result = std::toupper(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__toupper__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26253,7 +24015,7 @@ void test__va_arg__noreturn() {
 }
 
 void test__va_arg__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   va_arg(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26266,7 +24028,7 @@ void test__va_copy__noreturn() {
 }
 
 void test__va_copy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   va_copy(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26279,7 +24041,7 @@ void test__va_end__noreturn() {
 }
 
 void test__va_end__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   va_end(p);
   // cppcheck-suppress memleak
 }
@@ -26292,7 +24054,7 @@ void test__va_start__noreturn() {
 }
 
 void test__va_start__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   va_start(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26310,7 +24072,7 @@ void test__wcstof__useretval() {
 }
 
 void test__wcstof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcstof(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26339,12 +24101,6 @@ void test__std__wcstof__useretval() {
   std::wcstof(arg1, arg2);
 }
 
-void test__std__wcstof__leakignore() {
-  char *p = strdup(str);
-  result = std::wcstof(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstof__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -26370,7 +24126,7 @@ void test__wcstod__useretval() {
 }
 
 void test__wcstod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcstod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26399,12 +24155,6 @@ void test__std__wcstod__useretval() {
   std::wcstod(arg1, arg2);
 }
 
-void test__std__wcstod__leakignore() {
-  char *p = strdup(str);
-  result = std::wcstod(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstod__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -26430,7 +24180,7 @@ void test__wcstold__useretval() {
 }
 
 void test__wcstold__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcstold(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26459,12 +24209,6 @@ void test__std__wcstold__useretval() {
   std::wcstold(arg1, arg2);
 }
 
-void test__std__wcstold__leakignore() {
-  char *p = strdup(str);
-  result = std::wcstold(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstold__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -26490,7 +24234,7 @@ void test__stof__useretval() {
 }
 
 void test__stof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stof(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26519,12 +24263,6 @@ void test__std__stof__useretval() {
   std::stof(arg1, arg2);
 }
 
-void test__std__stof__leakignore() {
-  char *p = strdup(str);
-  result = std::stof(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stof__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26550,7 +24288,7 @@ void test__stod__useretval() {
 }
 
 void test__stod__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stod(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26579,12 +24317,6 @@ void test__std__stod__useretval() {
   std::stod(arg1, arg2);
 }
 
-void test__std__stod__leakignore() {
-  char *p = strdup(str);
-  result = std::stod(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stod__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26610,7 +24342,7 @@ void test__stold__useretval() {
 }
 
 void test__stold__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stold(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -26639,12 +24371,6 @@ void test__std__stold__useretval() {
   std::stold(arg1, arg2);
 }
 
-void test__std__stold__leakignore() {
-  char *p = strdup(str);
-  result = std::stold(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stold__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26670,7 +24396,7 @@ void test__stoi__useretval() {
 }
 
 void test__stoi__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stoi(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26705,12 +24431,6 @@ void test__std__stoi__useretval() {
   std::stoi(arg1, arg2, arg3);
 }
 
-void test__std__stoi__leakignore() {
-  char *p = strdup(str);
-  result = std::stoi(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stoi__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26742,7 +24462,7 @@ void test__stol__useretval() {
 }
 
 void test__stol__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stol(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26777,12 +24497,6 @@ void test__std__stol__useretval() {
   std::stol(arg1, arg2, arg3);
 }
 
-void test__std__stol__leakignore() {
-  char *p = strdup(str);
-  result = std::stol(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stol__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26814,7 +24528,7 @@ void test__stoll__useretval() {
 }
 
 void test__stoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stoll(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26849,12 +24563,6 @@ void test__std__stoll__useretval() {
   std::stoll(arg1, arg2, arg3);
 }
 
-void test__std__stoll__leakignore() {
-  char *p = strdup(str);
-  result = std::stoll(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stoll__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26886,7 +24594,7 @@ void test__stoul__useretval() {
 }
 
 void test__stoul__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stoul(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26921,12 +24629,6 @@ void test__std__stoul__useretval() {
   std::stoul(arg1, arg2, arg3);
 }
 
-void test__std__stoul__leakignore() {
-  char *p = strdup(str);
-  result = std::stoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stoul__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -26958,7 +24660,7 @@ void test__stoull__useretval() {
 }
 
 void test__stoull__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = stoull(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -26993,12 +24695,6 @@ void test__std__stoull__useretval() {
   std::stoull(arg1, arg2, arg3);
 }
 
-void test__std__stoull__leakignore() {
-  char *p = strdup(str);
-  result = std::stoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__stoull__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27029,12 +24725,6 @@ void test__std__to_string__useretval() {
   std::to_string(arg1);
 }
 
-void test__std__to_string__leakignore() {
-  char *p = strdup(str);
-  result = std::to_string(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__to_string__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27048,12 +24738,6 @@ void test__std__string__resize__noreturn() {
   x = 1 << x;
 }
 
-void test__std__string__resize__leakignore() {
-  char *p = strdup(str);
-  std::string::resize(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__resize__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27073,12 +24757,6 @@ void test__std__wstring__resize__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wstring__resize__leakignore() {
-  char *p = strdup(str);
-  std::wstring::resize(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__resize__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27103,12 +24781,6 @@ void test__std__to_wstring__useretval() {
   std::to_wstring(arg1);
 }
 
-void test__std__to_wstring__leakignore() {
-  char *p = strdup(str);
-  result = std::to_wstring(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__to_wstring__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27123,7 +24795,7 @@ void test__mbrtowc__noreturn() {
 }
 
 void test__mbrtowc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbrtowc(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -27153,12 +24825,6 @@ void test__std__mbrtowc__noreturn() {
   x = 1 << x;
 }
 
-void test__std__mbrtowc__leakignore() {
-  char *p = strdup(str);
-  std::mbrtowc(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__mbrtowc__arg2__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27185,7 +24851,7 @@ void test__wcstok__noreturn() {
 }
 
 void test__wcstok__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstok(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27221,12 +24887,6 @@ void test__std__wcstok__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstok__leakignore() {
-  char *p = strdup(str);
-  std::wcstok(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstok__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27264,7 +24924,7 @@ void test__wcstoimax__useretval() {
 }
 
 void test__wcstoimax__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcstoimax(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27299,12 +24959,6 @@ void test__std__wcstoimax__useretval() {
   std::wcstoimax(arg1, arg2, arg3);
 }
 
-void test__std__wcstoimax__leakignore() {
-  char *p = strdup(str);
-  result = std::wcstoimax(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstoimax__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27336,7 +24990,7 @@ void test__wcstoumax__useretval() {
 }
 
 void test__wcstoumax__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcstoumax(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27371,12 +25025,6 @@ void test__std__wcstoumax__useretval() {
   std::wcstoumax(arg1, arg2, arg3);
 }
 
-void test__std__wcstoumax__leakignore() {
-  char *p = strdup(str);
-  result = std::wcstoumax(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstoumax__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27403,7 +25051,7 @@ void test__wcstol__noreturn() {
 }
 
 void test__wcstol__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstol(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27433,12 +25081,6 @@ void test__std__wcstol__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstol__leakignore() {
-  char *p = strdup(str);
-  std::wcstol(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstol__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27465,7 +25107,7 @@ void test__wcstoll__noreturn() {
 }
 
 void test__wcstoll__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstoll(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27495,12 +25137,6 @@ void test__std__wcstoll__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstoll__leakignore() {
-  char *p = strdup(str);
-  std::wcstoll(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstoll__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27527,7 +25163,7 @@ void test__wcstoul__noreturn() {
 }
 
 void test__wcstoul__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstoul(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27557,12 +25193,6 @@ void test__std__wcstoul__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstoul__leakignore() {
-  char *p = strdup(str);
-  std::wcstoul(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstoul__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27589,7 +25219,7 @@ void test__wcstoull__noreturn() {
 }
 
 void test__wcstoull__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstoull(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27619,12 +25249,6 @@ void test__std__wcstoull__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wcstoull__leakignore() {
-  char *p = strdup(str);
-  std::wcstoull(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wcstoull__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27651,7 +25275,7 @@ void test__wprintf__noreturn() {
 }
 
 void test__wprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wprintf(p);
   // cppcheck-suppress memleak
 }
@@ -27669,12 +25293,6 @@ void test__std__wprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wprintf__leakignore() {
-  char *p = strdup(str);
-  std::wprintf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27689,7 +25307,7 @@ void test__sprintf__noreturn() {
 }
 
 void test__sprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -27719,12 +25337,6 @@ void test__std__sprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__sprintf__leakignore() {
-  char *p = strdup(str);
-  std::sprintf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27751,7 +25363,7 @@ void test__swprintf__noreturn() {
 }
 
 void test__swprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   swprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27787,12 +25399,6 @@ void test__std__swprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__swprintf__leakignore() {
-  char *p = strdup(str);
-  std::swprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__swprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -27825,7 +25431,7 @@ void test__vsprintf__noreturn() {
 }
 
 void test__vsprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -27855,12 +25461,6 @@ void test__std__vsprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vsprintf__leakignore() {
-  char *p = strdup(str);
-  std::vsprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vsprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27887,7 +25487,7 @@ void test__vswprintf__noreturn() {
 }
 
 void test__vswprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vswprintf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -27923,12 +25523,6 @@ void test__std__vswprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vswprintf__leakignore() {
-  char *p = strdup(str);
-  std::vswprintf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vswprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -27961,7 +25555,7 @@ void test__fwprintf__noreturn() {
 }
 
 void test__fwprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fwprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -27991,12 +25585,6 @@ void test__std__fwprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fwprintf__leakignore() {
-  char *p = strdup(str);
-  std::fwprintf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fwprintf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -28023,7 +25611,7 @@ void test__snprintf__noreturn() {
 }
 
 void test__snprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   snprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -28053,12 +25641,6 @@ void test__std__snprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__snprintf__leakignore() {
-  char *p = strdup(str);
-  std::snprintf(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__snprintf__arg2__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28085,7 +25667,7 @@ void test__vsnprintf__noreturn() {
 }
 
 void test__vsnprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsnprintf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -28121,12 +25703,6 @@ void test__std__vsnprintf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__vsnprintf__leakignore() {
-  char *p = strdup(str);
-  std::vsnprintf(p, arg2, arg3, arg4);
-  // cppcheck-suppress memleak
-}
-
 void test__std__vsnprintf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28159,7 +25735,7 @@ void test__wscanf__noreturn() {
 }
 
 void test__wscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wscanf(p);
   // cppcheck-suppress memleak
 }
@@ -28183,12 +25759,6 @@ void test__std__wscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wscanf__leakignore() {
-  char *p = strdup(str);
-  std::wscanf(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wscanf__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -28209,7 +25779,7 @@ void test__sscanf__noreturn() {
 }
 
 void test__sscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28239,12 +25809,6 @@ void test__std__sscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__sscanf__leakignore() {
-  char *p = strdup(str);
-  std::sscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__sscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28271,7 +25835,7 @@ void test__fwscanf__noreturn() {
 }
 
 void test__fwscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fwscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28295,12 +25859,6 @@ void test__std__fwscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fwscanf__leakignore() {
-  char *p = strdup(str);
-  std::fwscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fwscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28321,7 +25879,7 @@ void test__swscanf__noreturn() {
 }
 
 void test__swscanf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   swscanf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28345,12 +25903,6 @@ void test__std__swscanf__noreturn() {
   x = 1 << x;
 }
 
-void test__std__swscanf__leakignore() {
-  char *p = strdup(str);
-  std::swscanf(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__swscanf__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28371,7 +25923,7 @@ void test__system__noreturn() {
 }
 
 void test__system__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   system(p);
   // cppcheck-suppress memleak
 }
@@ -28389,12 +25941,6 @@ void test__std__system__noreturn() {
   x = 1 << x;
 }
 
-void test__std__system__leakignore() {
-  char *p = strdup(str);
-  std::system(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__system__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28409,7 +25955,7 @@ void test__setw__noreturn() {
 }
 
 void test__setw__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setw(p);
   // cppcheck-suppress memleak
 }
@@ -28427,12 +25973,6 @@ void test__std__setw__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setw__leakignore() {
-  char *p = strdup(str);
-  std::setw(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setw__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28452,7 +25992,7 @@ void test__min__useretval() {
 }
 
 void test__min__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = min(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28481,12 +26021,6 @@ void test__std__min__useretval() {
   std::min(arg1, arg2);
 }
 
-void test__std__min__leakignore() {
-  char *p = strdup(str);
-  result = std::min(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__min__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28512,7 +26046,7 @@ void test__max__useretval() {
 }
 
 void test__max__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = max(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28541,12 +26075,6 @@ void test__std__max__useretval() {
   std::max(arg1, arg2);
 }
 
-void test__std__max__leakignore() {
-  char *p = strdup(str);
-  result = std::max(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__max__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28567,7 +26095,7 @@ void test__setiosflags__noreturn() {
 }
 
 void test__setiosflags__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setiosflags(p);
   // cppcheck-suppress memleak
 }
@@ -28585,12 +26113,6 @@ void test__std__setiosflags__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setiosflags__leakignore() {
-  char *p = strdup(str);
-  std::setiosflags(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setiosflags__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28605,7 +26127,7 @@ void test__resetiosflags__noreturn() {
 }
 
 void test__resetiosflags__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   resetiosflags(p);
   // cppcheck-suppress memleak
 }
@@ -28623,12 +26145,6 @@ void test__std__resetiosflags__noreturn() {
   x = 1 << x;
 }
 
-void test__std__resetiosflags__leakignore() {
-  char *p = strdup(str);
-  std::resetiosflags(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__resetiosflags__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28643,7 +26159,7 @@ void test__setfill__noreturn() {
 }
 
 void test__setfill__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setfill(p);
   // cppcheck-suppress memleak
 }
@@ -28661,12 +26177,6 @@ void test__std__setfill__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setfill__leakignore() {
-  char *p = strdup(str);
-  std::setfill(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setfill__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28681,7 +26191,7 @@ void test__setprecision__noreturn() {
 }
 
 void test__setprecision__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setprecision(p);
   // cppcheck-suppress memleak
 }
@@ -28699,12 +26209,6 @@ void test__std__setprecision__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setprecision__leakignore() {
-  char *p = strdup(str);
-  std::setprecision(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setprecision__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28719,7 +26223,7 @@ void test__setbase__noreturn() {
 }
 
 void test__setbase__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setbase(p);
   // cppcheck-suppress memleak
 }
@@ -28737,12 +26241,6 @@ void test__std__setbase__noreturn() {
   x = 1 << x;
 }
 
-void test__std__setbase__leakignore() {
-  char *p = strdup(str);
-  std::setbase(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__setbase__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -28762,7 +26260,7 @@ void test__zonetime__useretval() {
 }
 
 void test__zonetime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = zonetime(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -28793,7 +26291,7 @@ void test__c16rtomb__noreturn() {
 }
 
 void test__c16rtomb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   c16rtomb(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -28824,7 +26322,7 @@ void test__c32rtomb__noreturn() {
 }
 
 void test__c32rtomb__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   c32rtomb(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -28855,7 +26353,7 @@ void test__mbrtoc16__noreturn() {
 }
 
 void test__mbrtoc16__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbrtoc16(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -28892,7 +26390,7 @@ void test__mbrtoc32__noreturn() {
 }
 
 void test__mbrtoc32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   mbrtoc32(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -30305,12 +27803,6 @@ void test__std__basic_string__find_last_not_of__useretval() {
   std::basic_string::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_last_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::find_last_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__find_last_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30347,12 +27839,6 @@ void test__std__string__find_last_not_of__useretval() {
   std::string::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_last_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::string::find_last_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__find_last_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30389,12 +27875,6 @@ void test__std__wstring__find_last_not_of__useretval() {
   std::wstring::find_last_not_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_last_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::find_last_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__find_last_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30431,12 +27911,6 @@ void test__std__basic_string__find_first_not_of__useretval() {
   std::basic_string::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::find_first_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__find_first_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30473,12 +27947,6 @@ void test__std__string__find_first_not_of__useretval() {
   std::string::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_first_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::string::find_first_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__find_first_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30515,12 +27983,6 @@ void test__std__wstring__find_first_not_of__useretval() {
   std::wstring::find_first_not_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_first_not_of__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::find_first_not_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__find_first_not_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30557,12 +28019,6 @@ void test__std__string__find__useretval() {
   std::string::find(arg1, arg2, arg3);
 }
 
-void test__std__string__find__leakignore() {
-  char *p = strdup(str);
-  result = std::string::find(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__find__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30599,12 +28055,6 @@ void test__std__string__rfind__useretval() {
   std::string::rfind(arg1, arg2, arg3);
 }
 
-void test__std__string__rfind__leakignore() {
-  char *p = strdup(str);
-  result = std::string::rfind(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__rfind__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30641,12 +28091,6 @@ void test__std__wstring__find__useretval() {
   std::wstring::find(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::find(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__find__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30683,12 +28127,6 @@ void test__std__wstring__rfind__useretval() {
   std::wstring::rfind(arg1, arg2, arg3);
 }
 
-void test__std__wstring__rfind__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::rfind(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__rfind__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30725,12 +28163,6 @@ void test__std__basic_string__find__useretval() {
   std::basic_string::find(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::find(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__find__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30767,12 +28199,6 @@ void test__std__basic_string__rfind__useretval() {
   std::basic_string::rfind(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__rfind__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::rfind(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__rfind__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30809,12 +28235,6 @@ void test__std__string__find_first_of__useretval() {
   std::string::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_first_of__leakignore() {
-  char *p = strdup(str);
-  result = std::string::find_first_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__find_first_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30851,12 +28271,6 @@ void test__std__wstring__find_first_of__useretval() {
   std::wstring::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_first_of__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::find_first_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__find_first_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30893,12 +28307,6 @@ void test__std__basic_string__find_first_of__useretval() {
   std::basic_string::find_first_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_first_of__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::find_first_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__find_first_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30935,12 +28343,6 @@ void test__std__string__find_last_of__useretval() {
   std::string::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__string__find_last_of__leakignore() {
-  char *p = strdup(str);
-  result = std::string::find_last_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__find_last_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -30977,12 +28379,6 @@ void test__std__wstring__find_last_of__useretval() {
   std::wstring::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__wstring__find_last_of__leakignore() {
-  char *p = strdup(str);
-  result = std::wstring::find_last_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__find_last_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31019,12 +28415,6 @@ void test__std__basic_string__find_last_of__useretval() {
   std::basic_string::find_last_of(arg1, arg2, arg3);
 }
 
-void test__std__basic_string__find_last_of__leakignore() {
-  char *p = strdup(str);
-  result = std::basic_string::find_last_of(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__find_last_of__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31176,12 +28566,6 @@ void test__std__ios__clear__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ios__clear__leakignore() {
-  char *p = strdup(str);
-  std::ios::clear(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ios__clear__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31195,12 +28579,6 @@ void test__std__fstream__clear__noreturn() {
   x = 1 << x;
 }
 
-void test__std__fstream__clear__leakignore() {
-  char *p = strdup(str);
-  std::fstream::clear(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__fstream__clear__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31214,12 +28592,6 @@ void test__std__istream__read__noreturn() {
   x = 1 << x;
 }
 
-void test__std__istream__read__leakignore() {
-  char *p = strdup(str);
-  std::istream::read(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__istream__read__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31239,12 +28611,6 @@ void test__std__ifstream__read__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ifstream__read__leakignore() {
-  char *p = strdup(str);
-  std::ifstream::read(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ifstream__read__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31264,12 +28630,6 @@ void test__std__istream__readsome__noreturn() {
   x = 1 << x;
 }
 
-void test__std__istream__readsome__leakignore() {
-  char *p = strdup(str);
-  std::istream::readsome(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__istream__readsome__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31289,12 +28649,6 @@ void test__std__ifstream__readsome__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ifstream__readsome__leakignore() {
-  char *p = strdup(str);
-  std::ifstream::readsome(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ifstream__readsome__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31314,12 +28668,6 @@ void test__std__istream__getline__noreturn() {
   x = 1 << x;
 }
 
-void test__std__istream__getline__leakignore() {
-  char *p = strdup(str);
-  std::istream::getline(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__istream__getline__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31345,12 +28693,6 @@ void test__std__ifstream__getline__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ifstream__getline__leakignore() {
-  char *p = strdup(str);
-  std::ifstream::getline(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ifstream__getline__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31376,12 +28718,6 @@ void test__std__istream__get__noreturn() {
   x = 1 << x;
 }
 
-void test__std__istream__get__leakignore() {
-  char *p = strdup(str);
-  std::istream::get(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__istream__get__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31407,12 +28743,6 @@ void test__std__ifstream__get__noreturn() {
   x = 1 << x;
 }
 
-void test__std__ifstream__get__leakignore() {
-  char *p = strdup(str);
-  std::ifstream::get(p, arg2, arg3);
-  // cppcheck-suppress memleak
-}
-
 void test__std__ifstream__get__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -31439,7 +28769,7 @@ void test__itoa__noreturn() {
 }
 
 void test__itoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   itoa(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -31469,12 +28799,6 @@ void test__std__string__erase__noreturn() {
   x = 1 << x;
 }
 
-void test__std__string__erase__leakignore() {
-  char *p = strdup(str);
-  std::string::erase(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__erase__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31494,12 +28818,6 @@ void test__std__wstring__erase__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wstring__erase__leakignore() {
-  char *p = strdup(str);
-  std::wstring::erase(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__erase__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31519,12 +28837,6 @@ void test__std__basic_string__erase__noreturn() {
   x = 1 << x;
 }
 
-void test__std__basic_string__erase__leakignore() {
-  char *p = strdup(str);
-  std::basic_string::erase(p, arg2);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__erase__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31544,12 +28856,6 @@ void test__std__string__reserve__noreturn() {
   x = 1 << x;
 }
 
-void test__std__string__reserve__leakignore() {
-  char *p = strdup(str);
-  std::string::reserve(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__string__reserve__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31563,12 +28869,6 @@ void test__std__wstring__reserve__noreturn() {
   x = 1 << x;
 }
 
-void test__std__wstring__reserve__leakignore() {
-  char *p = strdup(str);
-  std::wstring::reserve(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__wstring__reserve__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -31582,12 +28882,6 @@ void test__std__basic_string__reserve__noreturn() {
   x = 1 << x;
 }
 
-void test__std__basic_string__reserve__leakignore() {
-  char *p = strdup(str);
-  std::basic_string::reserve(p);
-  // cppcheck-suppress memleak
-}
-
 void test__std__basic_string__reserve__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -32219,7 +29513,7 @@ void test__offsetof__useretval() {
 }
 
 void test__offsetof__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = offsetof(p, arg2);
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-windows.cpp b/test/cfg/generated-cfg-tests-windows.cpp
index b57f57078..d7cb81b81 100644
--- a/test/cfg/generated-cfg-tests-windows.cpp
+++ b/test/cfg/generated-cfg-tests-windows.cpp
@@ -21,7 +21,7 @@ void test__RtlCompareMemory__useretval() {
 }
 
 void test__RtlCompareMemory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = RtlCompareMemory(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -63,7 +63,7 @@ void test__RtlCopyBytes__noreturn() {
 }
 
 void test__RtlCopyBytes__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RtlCopyBytes(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -99,7 +99,7 @@ void test__RtlFillBytes__noreturn() {
 }
 
 void test__RtlFillBytes__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RtlFillBytes(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -129,7 +129,7 @@ void test__RtlSecureZeroMemory__noreturn() {
 }
 
 void test__RtlSecureZeroMemory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RtlSecureZeroMemory(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -153,7 +153,7 @@ void test__RtlZeroBytes__noreturn() {
 }
 
 void test__RtlZeroBytes__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RtlZeroBytes(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -190,12 +190,6 @@ void test__CString__Format__noreturn() {
   x = 1 << x;
 }
 
-void test__CString__Format__leakignore() {
-  char *p = strdup(str);
-  CString::Format(p);
-  // cppcheck-suppress memleak
-}
-
 void test__CString__Format__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -209,12 +203,6 @@ void test__CString__AppendFormat__noreturn() {
   x = 1 << x;
 }
 
-void test__CString__AppendFormat__leakignore() {
-  char *p = strdup(str);
-  CString::AppendFormat(p);
-  // cppcheck-suppress memleak
-}
-
 void test__CString__AppendFormat__arg1__notuninit() {
   int x;
   // cppcheck-suppress uninitvar
@@ -229,7 +217,7 @@ void test__printf_s__noreturn() {
 }
 
 void test__printf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   printf_s(p);
   // cppcheck-suppress memleak
 }
@@ -254,7 +242,7 @@ void test__wprintf_s__noreturn() {
 }
 
 void test__wprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wprintf_s(p);
   // cppcheck-suppress memleak
 }
@@ -279,7 +267,7 @@ void test__fprintf_s__noreturn() {
 }
 
 void test__fprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fprintf_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -304,7 +292,7 @@ void test__fwprintf_s__noreturn() {
 }
 
 void test__fwprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   fwprintf_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -329,7 +317,7 @@ void test___snprintf_s__noreturn() {
 }
 
 void test___snprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _snprintf_s(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -354,7 +342,7 @@ void test___snwprintf_s__noreturn() {
 }
 
 void test___snwprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _snwprintf_s(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -379,7 +367,7 @@ void test__DbgPrint__noreturn() {
 }
 
 void test__DbgPrint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DbgPrint(p);
   // cppcheck-suppress memleak
 }
@@ -404,7 +392,7 @@ void test__DbgPrintEx__noreturn() {
 }
 
 void test__DbgPrintEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DbgPrintEx(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -429,7 +417,7 @@ void test__vDbgPrintEx__noreturn() {
 }
 
 void test__vDbgPrintEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vDbgPrintEx(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -454,7 +442,7 @@ void test__vDbgPrintExWithPrefix__noreturn() {
 }
 
 void test__vDbgPrintExWithPrefix__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vDbgPrintExWithPrefix(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -799,7 +787,7 @@ void test___mbstok__pure(int arg1,int arg2) {
 }
 
 void test___mbstok__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbstok(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -835,7 +823,7 @@ void test___tcstok__pure(int arg1,int arg2) {
 }
 
 void test___tcstok__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcstok(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -871,7 +859,7 @@ void test___mbstok_l__pure(int arg1,int arg2,int arg3) {
 }
 
 void test___mbstok_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbstok_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -913,7 +901,7 @@ void test___strtok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
 }
 
 void test___strtok_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _strtok_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -961,7 +949,7 @@ void test___wcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
 }
 
 void test___wcstok_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wcstok_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -1009,7 +997,7 @@ void test___mbstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
 }
 
 void test___mbstok_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbstok_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -1057,7 +1045,7 @@ void test___tcstok_s_l__pure(int arg1,int arg2,int arg3,int arg4) {
 }
 
 void test___tcstok_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcstok_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -1105,7 +1093,7 @@ void test__strtok_s__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__strtok_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strtok_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1147,7 +1135,7 @@ void test__wcstok_s__pure(int arg1,int arg2,int arg3) {
 }
 
 void test__wcstok_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcstok_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1189,7 +1177,7 @@ void test___mbstok_s__pure(int arg1,int arg2,int arg3) {
 }
 
 void test___mbstok_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbstok_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1231,7 +1219,7 @@ void test___tcstok_s__pure(int arg1,int arg2,int arg3) {
 }
 
 void test___tcstok_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcstok_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1268,7 +1256,7 @@ void test___getcwd__noreturn() {
 }
 
 void test___getcwd__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _getcwd(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1293,7 +1281,7 @@ void test___wgetcwd__noreturn() {
 }
 
 void test___wgetcwd__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wgetcwd(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1318,7 +1306,7 @@ void test__SHGetFolderPath__noreturn() {
 }
 
 void test__SHGetFolderPath__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SHGetFolderPath(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -1361,7 +1349,7 @@ void test__SHGetFolderPathA__noreturn() {
 }
 
 void test__SHGetFolderPathA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SHGetFolderPathA(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -1404,7 +1392,7 @@ void test__SHGetFolderPathW__noreturn() {
 }
 
 void test__SHGetFolderPathW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SHGetFolderPathW(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -1447,7 +1435,7 @@ void test__RegQueryValueEx__noreturn() {
 }
 
 void test__RegQueryValueEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegQueryValueEx(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -1478,7 +1466,7 @@ void test__RegQueryValueExA__noreturn() {
 }
 
 void test__RegQueryValueExA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegQueryValueExA(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -1509,7 +1497,7 @@ void test__RegQueryValueExW__noreturn() {
 }
 
 void test__RegQueryValueExW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegQueryValueExW(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -1540,7 +1528,7 @@ void test__RegCloseKey__noreturn() {
 }
 
 void test__RegCloseKey__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegCloseKey(p);
   // cppcheck-suppress memleak
 }
@@ -1559,7 +1547,7 @@ void test___stricmp_l__noreturn() {
 }
 
 void test___stricmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stricmp_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1602,7 +1590,7 @@ void test___wcsicmp_l__noreturn() {
 }
 
 void test___wcsicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wcsicmp_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1645,7 +1633,7 @@ void test___mbsicmp_l__noreturn() {
 }
 
 void test___mbsicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbsicmp_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -1688,7 +1676,7 @@ void test__stricmp__noreturn() {
 }
 
 void test__stricmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   stricmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1725,7 +1713,7 @@ void test___stricmp__noreturn() {
 }
 
 void test___stricmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stricmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1762,7 +1750,7 @@ void test__wcsicmp__noreturn() {
 }
 
 void test__wcsicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcsicmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1799,7 +1787,7 @@ void test___wcsicmp__noreturn() {
 }
 
 void test___wcsicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wcsicmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1836,7 +1824,7 @@ void test___mbsicmp__noreturn() {
 }
 
 void test___mbsicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbsicmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1873,7 +1861,7 @@ void test___tcsicmp__noreturn() {
 }
 
 void test___tcsicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcsicmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -1910,7 +1898,7 @@ void test__GetFileAttributes__noreturn() {
 }
 
 void test__GetFileAttributes__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetFileAttributes(p);
   // cppcheck-suppress memleak
 }
@@ -1929,7 +1917,7 @@ void test__GetFileAttributesA__noreturn() {
 }
 
 void test__GetFileAttributesA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetFileAttributesA(p);
   // cppcheck-suppress memleak
 }
@@ -1948,7 +1936,7 @@ void test__GetFileAttributesW__noreturn() {
 }
 
 void test__GetFileAttributesW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetFileAttributesW(p);
   // cppcheck-suppress memleak
 }
@@ -1967,7 +1955,7 @@ void test__RegOpenKeyEx__noreturn() {
 }
 
 void test__RegOpenKeyEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegOpenKeyEx(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -1998,7 +1986,7 @@ void test__RegOpenKeyExA__noreturn() {
 }
 
 void test__RegOpenKeyExA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegOpenKeyExA(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2029,7 +2017,7 @@ void test__RegOpenKeyExW__noreturn() {
 }
 
 void test__RegOpenKeyExW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegOpenKeyExW(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2060,7 +2048,7 @@ void test__wsprintf__noreturn() {
 }
 
 void test__wsprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wsprintf(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2091,7 +2079,7 @@ void test__wsprintfA__noreturn() {
 }
 
 void test__wsprintfA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wsprintfA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2122,7 +2110,7 @@ void test__wsprintfW__noreturn() {
 }
 
 void test__wsprintfW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wsprintfW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2153,7 +2141,7 @@ void test__sprintf_s__noreturn() {
 }
 
 void test__sprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sprintf_s();
   // cppcheck-suppress memleak
 }
@@ -2166,7 +2154,7 @@ void test__swprintf_s__noreturn() {
 }
 
 void test__swprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   swprintf_s();
   // cppcheck-suppress memleak
 }
@@ -2179,7 +2167,7 @@ void test___sprintf_s_l__noreturn() {
 }
 
 void test___sprintf_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _sprintf_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2216,7 +2204,7 @@ void test___swprintf_s_l__noreturn() {
 }
 
 void test___swprintf_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _swprintf_s_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2253,7 +2241,7 @@ void test__RegEnumKeyEx__noreturn() {
 }
 
 void test__RegEnumKeyEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegEnumKeyEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
   // cppcheck-suppress memleak
 }
@@ -2278,7 +2266,7 @@ void test__RegEnumKeyExA__noreturn() {
 }
 
 void test__RegEnumKeyExA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegEnumKeyExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
   // cppcheck-suppress memleak
 }
@@ -2303,7 +2291,7 @@ void test__RegEnumKeyExW__noreturn() {
 }
 
 void test__RegEnumKeyExW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegEnumKeyExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
   // cppcheck-suppress memleak
 }
@@ -2354,7 +2342,7 @@ void test___vsnprintf__noreturn() {
 }
 
 void test___vsnprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnprintf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2391,7 +2379,7 @@ void test___vsnwprintf__noreturn() {
 }
 
 void test___vsnwprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnwprintf(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2428,7 +2416,7 @@ void test___vsnprintf_l__noreturn() {
 }
 
 void test___vsnprintf_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnprintf_l(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2471,7 +2459,7 @@ void test___vsnwprintf_l__noreturn() {
 }
 
 void test___vsnwprintf_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnwprintf_l(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2514,7 +2502,7 @@ void test___vswprintf_l__noreturn() {
 }
 
 void test___vswprintf_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vswprintf_l(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2557,7 +2545,7 @@ void test__vsnprintf_s__noreturn() {
 }
 
 void test__vsnprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   vsnprintf_s(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2600,7 +2588,7 @@ void test___vsnprintf_s__noreturn() {
 }
 
 void test___vsnprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnprintf_s(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2643,7 +2631,7 @@ void test___vsnwprintf_s__noreturn() {
 }
 
 void test___vsnwprintf_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnwprintf_s(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -2686,7 +2674,7 @@ void test___vsnprintf_s_l__noreturn() {
 }
 
 void test___vsnprintf_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -2735,7 +2723,7 @@ void test___vsnwprintf_s_l__noreturn() {
 }
 
 void test___vsnwprintf_s_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsnwprintf_s_l(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -2784,7 +2772,7 @@ void test___vsprintf_l__noreturn() {
 }
 
 void test___vsprintf_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _vsprintf_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2815,7 +2803,7 @@ void test____vswprintf_l__noreturn() {
 }
 
 void test____vswprintf_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   __vswprintf_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -3043,7 +3031,7 @@ void test___mbscmp__pure(int arg1,int arg2) {
 }
 
 void test___mbscmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbscmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3090,7 +3078,7 @@ void test___tcscmp__pure(int arg1,int arg2) {
 }
 
 void test___tcscmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcscmp(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3127,7 +3115,7 @@ void test___snprintf__noreturn() {
 }
 
 void test___snprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _snprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3158,7 +3146,7 @@ void test___snwprintf__noreturn() {
 }
 
 void test___snwprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _snwprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3189,7 +3177,7 @@ void test___sntprintf__noreturn() {
 }
 
 void test___sntprintf__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _sntprintf(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3220,7 +3208,7 @@ void test__strcpy_s__noreturn() {
 }
 
 void test__strcpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   strcpy_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3257,7 +3245,7 @@ void test__wcscpy_s__noreturn() {
 }
 
 void test__wcscpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wcscpy_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3294,7 +3282,7 @@ void test___mbscpy_s__noreturn() {
 }
 
 void test___mbscpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbscpy_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3331,7 +3319,7 @@ void test___tcscpy_s__noreturn() {
 }
 
 void test___tcscpy_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcscpy_s(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -3368,7 +3356,7 @@ void test___CrtSetDbgFlag__noreturn() {
 }
 
 void test___CrtSetDbgFlag__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _CrtSetDbgFlag(p);
   // cppcheck-suppress memleak
 }
@@ -3387,7 +3375,7 @@ void test___stat__noreturn() {
 }
 
 void test___stat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3418,7 +3406,7 @@ void test___tstat__noreturn() {
 }
 
 void test___tstat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tstat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3449,7 +3437,7 @@ void test___stat32__noreturn() {
 }
 
 void test___stat32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stat32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3480,7 +3468,7 @@ void test___stat64__noreturn() {
 }
 
 void test___stat64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stat64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3511,7 +3499,7 @@ void test___tstat64__noreturn() {
 }
 
 void test___tstat64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tstat64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3542,7 +3530,7 @@ void test___stati64__noreturn() {
 }
 
 void test___stati64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stati64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3573,7 +3561,7 @@ void test___tstati64__noreturn() {
 }
 
 void test___tstati64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tstati64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3604,7 +3592,7 @@ void test___stat32i64__noreturn() {
 }
 
 void test___stat32i64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stat32i64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3635,7 +3623,7 @@ void test___tstat32i64__noreturn() {
 }
 
 void test___tstat32i64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tstat32i64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3666,7 +3654,7 @@ void test___stat64i32__noreturn() {
 }
 
 void test___stat64i32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _stat64i32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3697,7 +3685,7 @@ void test___tstat64i32__noreturn() {
 }
 
 void test___tstat64i32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tstat64i32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3728,7 +3716,7 @@ void test___wstat__noreturn() {
 }
 
 void test___wstat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3759,7 +3747,7 @@ void test___wstat32__noreturn() {
 }
 
 void test___wstat32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstat32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3790,7 +3778,7 @@ void test___wstat64__noreturn() {
 }
 
 void test___wstat64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstat64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3821,7 +3809,7 @@ void test___wstati64__noreturn() {
 }
 
 void test___wstati64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstati64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3852,7 +3840,7 @@ void test___wstat32i64__noreturn() {
 }
 
 void test___wstat32i64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstat32i64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3883,7 +3871,7 @@ void test___wstat64i32__noreturn() {
 }
 
 void test___wstat64i32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wstat64i32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3914,7 +3902,7 @@ void test___fstat__noreturn() {
 }
 
 void test___fstat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3939,7 +3927,7 @@ void test___fstat32__noreturn() {
 }
 
 void test___fstat32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstat32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3964,7 +3952,7 @@ void test___fstat64__noreturn() {
 }
 
 void test___fstat64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstat64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -3989,7 +3977,7 @@ void test___fstati64__noreturn() {
 }
 
 void test___fstati64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstati64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4014,7 +4002,7 @@ void test___fstat32i64__noreturn() {
 }
 
 void test___fstat32i64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstat32i64(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4039,7 +4027,7 @@ void test___fstat64i32__noreturn() {
 }
 
 void test___fstat64i32__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fstat64i32(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4064,7 +4052,7 @@ void test___fseeki64__noreturn() {
 }
 
 void test___fseeki64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _fseeki64(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4106,7 +4094,7 @@ void test___ftelli64__useretval() {
 }
 
 void test___ftelli64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _ftelli64(p);
   // cppcheck-suppress memleak
 }
@@ -4136,7 +4124,7 @@ void test___ftell_nolock__useretval() {
 }
 
 void test___ftell_nolock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _ftell_nolock(p);
   // cppcheck-suppress memleak
 }
@@ -4166,7 +4154,7 @@ void test___ftelli64_nolock__useretval() {
 }
 
 void test___ftelli64_nolock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _ftelli64_nolock(p);
   // cppcheck-suppress memleak
 }
@@ -4268,7 +4256,7 @@ void test__strnlen_s__useretval() {
 }
 
 void test__strnlen_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = strnlen_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4304,7 +4292,7 @@ void test__wcsnlen_s__useretval() {
 }
 
 void test__wcsnlen_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wcsnlen_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4340,7 +4328,7 @@ void test___mbsnlen__useretval() {
 }
 
 void test___mbsnlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsnlen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4376,7 +4364,7 @@ void test___mbstrnlen__useretval() {
 }
 
 void test___mbstrnlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbstrnlen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4412,7 +4400,7 @@ void test___mbsnlen_l__useretval() {
 }
 
 void test___mbsnlen_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsnlen_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4454,7 +4442,7 @@ void test___mbstrnlen_l__useretval() {
 }
 
 void test___mbstrnlen_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbstrnlen_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -4491,7 +4479,7 @@ void test__WideCharToMultiByte__noreturn() {
 }
 
 void test__WideCharToMultiByte__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   WideCharToMultiByte(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
   // cppcheck-suppress memleak
 }
@@ -4545,7 +4533,7 @@ void test__PathIsDirectory__useretval() {
 }
 
 void test__PathIsDirectory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = PathIsDirectory(p);
   // cppcheck-suppress memleak
 }
@@ -4569,7 +4557,7 @@ void test__PathIsDirectoryA__useretval() {
 }
 
 void test__PathIsDirectoryA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = PathIsDirectoryA(p);
   // cppcheck-suppress memleak
 }
@@ -4593,7 +4581,7 @@ void test__PathIsDirectoryW__useretval() {
 }
 
 void test__PathIsDirectoryW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = PathIsDirectoryW(p);
   // cppcheck-suppress memleak
 }
@@ -4612,7 +4600,7 @@ void test__SetConsoleTextAttribute__noreturn() {
 }
 
 void test__SetConsoleTextAttribute__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetConsoleTextAttribute(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4711,7 +4699,7 @@ void test__DeleteFile__noreturn() {
 }
 
 void test__DeleteFile__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DeleteFile(p);
   // cppcheck-suppress memleak
 }
@@ -4730,7 +4718,7 @@ void test__DeleteFileA__noreturn() {
 }
 
 void test__DeleteFileA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DeleteFileA(p);
   // cppcheck-suppress memleak
 }
@@ -4749,7 +4737,7 @@ void test__DeleteFileW__noreturn() {
 }
 
 void test__DeleteFileW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DeleteFileW(p);
   // cppcheck-suppress memleak
 }
@@ -4773,7 +4761,7 @@ void test__GetStdHandle__useretval() {
 }
 
 void test__GetStdHandle__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetStdHandle(p);
   // cppcheck-suppress memleak
 }
@@ -4792,7 +4780,7 @@ void test__SetStdHandle__noreturn() {
 }
 
 void test__SetStdHandle__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetStdHandle(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4817,7 +4805,7 @@ void test___access__noreturn() {
 }
 
 void test___access__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _access(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4848,7 +4836,7 @@ void test___waccess__noreturn() {
 }
 
 void test___waccess__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _waccess(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4879,7 +4867,7 @@ void test___taccess__noreturn() {
 }
 
 void test___taccess__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _taccess(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -4910,7 +4898,7 @@ void test__PeekMessage__noreturn() {
 }
 
 void test__PeekMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   PeekMessage(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -4953,7 +4941,7 @@ void test__PeekMessageA__noreturn() {
 }
 
 void test__PeekMessageA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   PeekMessageA(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -4996,7 +4984,7 @@ void test__PeekMessageW__noreturn() {
 }
 
 void test__PeekMessageW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   PeekMessageW(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -5039,7 +5027,7 @@ void test__GetMessage__noreturn() {
 }
 
 void test__GetMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetMessage(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5076,7 +5064,7 @@ void test__GetMessageA__noreturn() {
 }
 
 void test__GetMessageA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetMessageA(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5113,7 +5101,7 @@ void test__GetMessageW__noreturn() {
 }
 
 void test__GetMessageW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetMessageW(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5150,7 +5138,7 @@ void test__TranslateMessage__noreturn() {
 }
 
 void test__TranslateMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   TranslateMessage(p);
   // cppcheck-suppress memleak
 }
@@ -5175,7 +5163,7 @@ void test__DispatchMessage__noreturn() {
 }
 
 void test__DispatchMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DispatchMessage(p);
   // cppcheck-suppress memleak
 }
@@ -5200,7 +5188,7 @@ void test__DispatchMessageA__noreturn() {
 }
 
 void test__DispatchMessageA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DispatchMessageA(p);
   // cppcheck-suppress memleak
 }
@@ -5225,7 +5213,7 @@ void test__DispatchMessageW__noreturn() {
 }
 
 void test__DispatchMessageW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DispatchMessageW(p);
   // cppcheck-suppress memleak
 }
@@ -5472,7 +5460,7 @@ void test__PostQuitMessage__noreturn() {
 }
 
 void test__PostQuitMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   PostQuitMessage(p);
   // cppcheck-suppress memleak
 }
@@ -5491,7 +5479,7 @@ void test__DefWindowProc__noreturn() {
 }
 
 void test__DefWindowProc__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DefWindowProc(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5534,7 +5522,7 @@ void test__DefWindowProcA__noreturn() {
 }
 
 void test__DefWindowProcA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DefWindowProcA(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5577,7 +5565,7 @@ void test__DefWindowProcW__noreturn() {
 }
 
 void test__DefWindowProcW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   DefWindowProcW(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5625,7 +5613,7 @@ void test__GetPrivateProfileInt__useretval() {
 }
 
 void test__GetPrivateProfileInt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetPrivateProfileInt(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5685,7 +5673,7 @@ void test__GetPrivateProfileIntA__useretval() {
 }
 
 void test__GetPrivateProfileIntA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetPrivateProfileIntA(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5745,7 +5733,7 @@ void test__GetPrivateProfileIntW__useretval() {
 }
 
 void test__GetPrivateProfileIntW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetPrivateProfileIntW(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5800,7 +5788,7 @@ void test__GetPrivateProfileSection__noreturn() {
 }
 
 void test__GetPrivateProfileSection__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSection(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5849,7 +5837,7 @@ void test__GetPrivateProfileSectionA__noreturn() {
 }
 
 void test__GetPrivateProfileSectionA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSectionA(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5898,7 +5886,7 @@ void test__GetPrivateProfileSectionW__noreturn() {
 }
 
 void test__GetPrivateProfileSectionW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSectionW(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -5947,7 +5935,7 @@ void test__GetPrivateProfileSectionNames__noreturn() {
 }
 
 void test__GetPrivateProfileSectionNames__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSectionNames(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -5984,7 +5972,7 @@ void test__GetPrivateProfileSectionNamesA__noreturn() {
 }
 
 void test__GetPrivateProfileSectionNamesA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSectionNamesA(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6021,7 +6009,7 @@ void test__GetPrivateProfileSectionNamesW__noreturn() {
 }
 
 void test__GetPrivateProfileSectionNamesW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileSectionNamesW(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -6058,7 +6046,7 @@ void test__GetPrivateProfileString__noreturn() {
 }
 
 void test__GetPrivateProfileString__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileString(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -6113,7 +6101,7 @@ void test__GetPrivateProfileStringA__noreturn() {
 }
 
 void test__GetPrivateProfileStringA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileStringA(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -6168,7 +6156,7 @@ void test__GetPrivateProfileStringW__noreturn() {
 }
 
 void test__GetPrivateProfileStringW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileStringW(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -6223,7 +6211,7 @@ void test__GetPrivateProfileStruct__noreturn() {
 }
 
 void test__GetPrivateProfileStruct__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileStruct(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -6284,7 +6272,7 @@ void test__GetPrivateProfileStructA__noreturn() {
 }
 
 void test__GetPrivateProfileStructA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileStructA(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -6345,7 +6333,7 @@ void test__GetPrivateProfileStructW__noreturn() {
 }
 
 void test__GetPrivateProfileStructW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetPrivateProfileStructW(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -6406,7 +6394,7 @@ void test__BeginPaint__noreturn() {
 }
 
 void test__BeginPaint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   BeginPaint(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6431,7 +6419,7 @@ void test__EndPaint__noreturn() {
 }
 
 void test__EndPaint__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   EndPaint(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6466,7 +6454,7 @@ void test__GetStockObject__pure(int arg1) {
 }
 
 void test__GetStockObject__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetStockObject(p);
   // cppcheck-suppress memleak
 }
@@ -6490,7 +6478,7 @@ void test__LoadIcon__useretval() {
 }
 
 void test__LoadIcon__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = LoadIcon(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6526,7 +6514,7 @@ void test__LoadIconA__useretval() {
 }
 
 void test__LoadIconA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = LoadIconA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6562,7 +6550,7 @@ void test__LoadIconW__useretval() {
 }
 
 void test__LoadIconW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = LoadIconW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6598,7 +6586,7 @@ void test__CreateSolidBrush__useretval() {
 }
 
 void test__CreateSolidBrush__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateSolidBrush(p);
   // cppcheck-suppress memleak
 }
@@ -6617,7 +6605,7 @@ void test__UpdateWindow__noreturn() {
 }
 
 void test__UpdateWindow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   UpdateWindow(p);
   // cppcheck-suppress memleak
 }
@@ -6642,7 +6630,7 @@ void test__EnableWindow__noreturn() {
 }
 
 void test__EnableWindow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   EnableWindow(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -6678,7 +6666,7 @@ void test__CreateWindow__useretval() {
 }
 
 void test__CreateWindow__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindow(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -6762,7 +6750,7 @@ void test__CreateWindowA__useretval() {
 }
 
 void test__CreateWindowA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindowA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -6846,7 +6834,7 @@ void test__CreateWindowW__useretval() {
 }
 
 void test__CreateWindowW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindowW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -6930,7 +6918,7 @@ void test__CreateWindowEx__useretval() {
 }
 
 void test__CreateWindowEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindowEx(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -7020,7 +7008,7 @@ void test__CreateWindowExA__useretval() {
 }
 
 void test__CreateWindowExA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindowExA(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -7110,7 +7098,7 @@ void test__CreateWindowExW__useretval() {
 }
 
 void test__CreateWindowExW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = CreateWindowExW(p, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
   // cppcheck-suppress memleak
 }
@@ -7195,7 +7183,7 @@ void test__SetWindowText__noreturn() {
 }
 
 void test__SetWindowText__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetWindowText(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7232,7 +7220,7 @@ void test__SetWindowTextA__noreturn() {
 }
 
 void test__SetWindowTextA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetWindowTextA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7269,7 +7257,7 @@ void test__SetWindowTextW__noreturn() {
 }
 
 void test__SetWindowTextW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetWindowTextW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7306,7 +7294,7 @@ void test__RegisterClass__noreturn() {
 }
 
 void test__RegisterClass__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegisterClass(p);
   // cppcheck-suppress memleak
 }
@@ -7331,7 +7319,7 @@ void test__RegisterClassEx__noreturn() {
 }
 
 void test__RegisterClassEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RegisterClassEx(p);
   // cppcheck-suppress memleak
 }
@@ -7413,7 +7401,7 @@ void test__MessageBox__noreturn() {
 }
 
 void test__MessageBox__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   MessageBox(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -7450,7 +7438,7 @@ void test__MessageBoxA__noreturn() {
 }
 
 void test__MessageBoxA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   MessageBoxA(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -7487,7 +7475,7 @@ void test__MessageBoxW__noreturn() {
 }
 
 void test__MessageBoxW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   MessageBoxW(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -7524,7 +7512,7 @@ void test__GlobalLock__noreturn() {
 }
 
 void test__GlobalLock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GlobalLock(p);
   // cppcheck-suppress memleak
 }
@@ -7549,7 +7537,7 @@ void test__GlobalUnlock__noreturn() {
 }
 
 void test__GlobalUnlock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GlobalUnlock(p);
   // cppcheck-suppress memleak
 }
@@ -7574,7 +7562,7 @@ void test__OpenClipboard__noreturn() {
 }
 
 void test__OpenClipboard__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   OpenClipboard(p);
   // cppcheck-suppress memleak
 }
@@ -7593,7 +7581,7 @@ void test__EmptyClipboard__noreturn() {
 }
 
 void test__EmptyClipboard__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   EmptyClipboard();
   // cppcheck-suppress memleak
 }
@@ -7606,7 +7594,7 @@ void test__CloseClipboard__noreturn() {
 }
 
 void test__CloseClipboard__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   CloseClipboard();
   // cppcheck-suppress memleak
 }
@@ -7619,7 +7607,7 @@ void test__SetClipboardData__noreturn() {
 }
 
 void test__SetClipboardData__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetClipboardData(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -7644,7 +7632,7 @@ void test___rmdir__noreturn() {
 }
 
 void test___rmdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _rmdir(p);
   // cppcheck-suppress memleak
 }
@@ -7669,7 +7657,7 @@ void test___wrmdir__noreturn() {
 }
 
 void test___wrmdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wrmdir(p);
   // cppcheck-suppress memleak
 }
@@ -7694,7 +7682,7 @@ void test___mkdir__noreturn() {
 }
 
 void test___mkdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mkdir(p);
   // cppcheck-suppress memleak
 }
@@ -7719,7 +7707,7 @@ void test___wmkdir__noreturn() {
 }
 
 void test___wmkdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wmkdir(p);
   // cppcheck-suppress memleak
 }
@@ -7754,7 +7742,7 @@ void test___abs64__pure(int arg1) {
 }
 
 void test___abs64__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _abs64(p);
   // cppcheck-suppress memleak
 }
@@ -7808,7 +7796,7 @@ void test__SetWaitableTimer__noreturn() {
 }
 
 void test__SetWaitableTimer__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetWaitableTimer(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -7863,7 +7851,7 @@ void test__WaitForSingleObject__noreturn() {
 }
 
 void test__WaitForSingleObject__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   WaitForSingleObject(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8020,7 +8008,7 @@ void test___mktemp__useretval() {
 }
 
 void test___mktemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mktemp(p);
   // cppcheck-suppress memleak
 }
@@ -8050,7 +8038,7 @@ void test___wmktemp__useretval() {
 }
 
 void test___wmktemp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _wmktemp(p);
   // cppcheck-suppress memleak
 }
@@ -8375,7 +8363,7 @@ void test__FindNextFile__useretval() {
 }
 
 void test__FindNextFile__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = FindNextFile(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8411,7 +8399,7 @@ void test__FindNextFileW__useretval() {
 }
 
 void test__FindNextFileW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = FindNextFileW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8447,7 +8435,7 @@ void test__FindNextFileA__useretval() {
 }
 
 void test__FindNextFileA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = FindNextFileA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8478,7 +8466,7 @@ void test__SetEnvironmentVariable__noreturn() {
 }
 
 void test__SetEnvironmentVariable__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetEnvironmentVariable(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8497,7 +8485,7 @@ void test__SetEnvironmentVariableW__noreturn() {
 }
 
 void test__SetEnvironmentVariableW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetEnvironmentVariableW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8516,7 +8504,7 @@ void test__SetEnvironmentVariableA__noreturn() {
 }
 
 void test__SetEnvironmentVariableA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetEnvironmentVariableA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8540,7 +8528,7 @@ void test__QueryDosDevice__useretval() {
 }
 
 void test__QueryDosDevice__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = QueryDosDevice(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8570,7 +8558,7 @@ void test__QueryDosDeviceW__useretval() {
 }
 
 void test__QueryDosDeviceW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = QueryDosDeviceW(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8600,7 +8588,7 @@ void test__QueryDosDeviceA__useretval() {
 }
 
 void test__QueryDosDeviceA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = QueryDosDeviceA(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8630,7 +8618,7 @@ void test__GetDefaultCommConfig__useretval() {
 }
 
 void test__GetDefaultCommConfig__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetDefaultCommConfig(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8660,7 +8648,7 @@ void test__GetDefaultCommConfigW__useretval() {
 }
 
 void test__GetDefaultCommConfigW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetDefaultCommConfigW(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8690,7 +8678,7 @@ void test__GetDefaultCommConfigA__useretval() {
 }
 
 void test__GetDefaultCommConfigA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetDefaultCommConfigA(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8715,7 +8703,7 @@ void test__GetTempPath__noreturn() {
 }
 
 void test__GetTempPath__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetTempPath(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8734,7 +8722,7 @@ void test__GetTempPathW__noreturn() {
 }
 
 void test__GetTempPathW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetTempPathW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8753,7 +8741,7 @@ void test__GetTempPathA__noreturn() {
 }
 
 void test__GetTempPathA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetTempPathA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8772,7 +8760,7 @@ void test__SetupDiDestroyDeviceInfoList__noreturn() {
 }
 
 void test__SetupDiDestroyDeviceInfoList__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetupDiDestroyDeviceInfoList(p);
   // cppcheck-suppress memleak
 }
@@ -8791,7 +8779,7 @@ void test__SetupDiGetDeviceInstanceId__noreturn() {
 }
 
 void test__SetupDiGetDeviceInstanceId__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetupDiGetDeviceInstanceId(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -8822,7 +8810,7 @@ void test__SetupDiEnumDeviceInfo__noreturn() {
 }
 
 void test__SetupDiEnumDeviceInfo__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetupDiEnumDeviceInfo(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -8847,7 +8835,7 @@ void test__SetupDiGetClassDevs__noreturn() {
 }
 
 void test__SetupDiGetClassDevs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetupDiGetClassDevs(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -8883,7 +8871,7 @@ void test___mbsstr__useretval() {
 }
 
 void test___mbsstr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsstr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8925,7 +8913,7 @@ void test___tcsstr__useretval() {
 }
 
 void test___tcsstr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsstr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -8967,7 +8955,7 @@ void test___mbsstr_l__useretval() {
 }
 
 void test___mbsstr_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsstr_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9010,7 +8998,7 @@ void test___memccpy__noreturn() {
 }
 
 void test___memccpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _memccpy(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9181,7 +9169,7 @@ void test___swab__noreturn() {
 }
 
 void test___swab__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _swab(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9228,7 +9216,7 @@ void test___strnicmp__useretval() {
 }
 
 void test___strnicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _strnicmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9281,7 +9269,7 @@ void test___wcsnicmp__useretval() {
 }
 
 void test___wcsnicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _wcsnicmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9334,7 +9322,7 @@ void test___mbsnicmp__useretval() {
 }
 
 void test___mbsnicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsnicmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9387,7 +9375,7 @@ void test___tcsncicmp__useretval() {
 }
 
 void test___tcsncicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsncicmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9440,7 +9428,7 @@ void test___tcsnicmp__useretval() {
 }
 
 void test___tcsnicmp__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsnicmp(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -9493,7 +9481,7 @@ void test___strnicmp_l__useretval() {
 }
 
 void test___strnicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _strnicmp_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9552,7 +9540,7 @@ void test___wcsnicmp_l__useretval() {
 }
 
 void test___wcsnicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _wcsnicmp_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9611,7 +9599,7 @@ void test___mbsnicmp_l__useretval() {
 }
 
 void test___mbsnicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsnicmp_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9670,7 +9658,7 @@ void test___tcsncicmp_l__useretval() {
 }
 
 void test___tcsncicmp_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsncicmp_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -9830,7 +9818,7 @@ void test___mbslen_l__pure(int arg1,int arg2) {
 }
 
 void test___mbslen_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbslen_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9871,7 +9859,7 @@ void test___mbstrlen_l__pure(int arg1,int arg2) {
 }
 
 void test___mbstrlen_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbstrlen_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9912,7 +9900,7 @@ void test___tcsclen_l__pure(int arg1,int arg2) {
 }
 
 void test___tcsclen_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsclen_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -9953,7 +9941,7 @@ void test___mbslen__pure(int arg1) {
 }
 
 void test___mbslen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbslen(p);
   // cppcheck-suppress memleak
 }
@@ -9988,7 +9976,7 @@ void test___mbstrlen__pure(int arg1) {
 }
 
 void test___mbstrlen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbstrlen(p);
   // cppcheck-suppress memleak
 }
@@ -10023,7 +10011,7 @@ void test___tcslen__pure(int arg1) {
 }
 
 void test___tcslen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcslen(p);
   // cppcheck-suppress memleak
 }
@@ -10058,7 +10046,7 @@ void test___tcsclen__pure(int arg1) {
 }
 
 void test___tcsclen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsclen(p);
   // cppcheck-suppress memleak
 }
@@ -10088,7 +10076,7 @@ void test___mbsrchr_l__useretval() {
 }
 
 void test___mbsrchr_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsrchr_l(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10130,7 +10118,7 @@ void test___mbsrchr__useretval() {
 }
 
 void test___mbsrchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _mbsrchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10166,7 +10154,7 @@ void test___tcsrchr__useretval() {
 }
 
 void test___tcsrchr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tcsrchr(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10197,7 +10185,7 @@ void test___strftime_l__noreturn() {
 }
 
 void test___strftime_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _strftime_l(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -10252,7 +10240,7 @@ void test___wcsftime_l__noreturn() {
 }
 
 void test___wcsftime_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wcsftime_l(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -10307,7 +10295,7 @@ void test___tcsftime__noreturn() {
 }
 
 void test___tcsftime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcsftime(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10536,7 +10524,7 @@ void test___mbsncpy__noreturn() {
 }
 
 void test___mbsncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbsncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10578,7 +10566,7 @@ void test___mbsnbcpy__noreturn() {
 }
 
 void test___mbsnbcpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbsnbcpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10620,7 +10608,7 @@ void test___tcsncpy__noreturn() {
 }
 
 void test___tcsncpy__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcsncpy(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -10662,7 +10650,7 @@ void test___strncpy_l__noreturn() {
 }
 
 void test___strncpy_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _strncpy_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10710,7 +10698,7 @@ void test___wcsncpy_l__noreturn() {
 }
 
 void test___wcsncpy_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _wcsncpy_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10758,7 +10746,7 @@ void test___mbsncpy_l__noreturn() {
 }
 
 void test___mbsncpy_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _mbsncpy_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10806,7 +10794,7 @@ void test___tcsncpy_l__noreturn() {
 }
 
 void test___tcsncpy_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _tcsncpy_l(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -10854,7 +10842,7 @@ void test___localtime32_s__noreturn() {
 }
 
 void test___localtime32_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _localtime32_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10879,7 +10867,7 @@ void test___localtime64_s__noreturn() {
 }
 
 void test___localtime64_s__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _localtime64_s(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10904,7 +10892,7 @@ void test__CreateDirectory__noreturn() {
 }
 
 void test__CreateDirectory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   CreateDirectory(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10929,7 +10917,7 @@ void test__CreateDirectoryA__noreturn() {
 }
 
 void test__CreateDirectoryA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   CreateDirectoryA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10954,7 +10942,7 @@ void test__CreateDirectoryW__noreturn() {
 }
 
 void test__CreateDirectoryW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   CreateDirectoryW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -10979,7 +10967,7 @@ void test__RemoveDirectory__noreturn() {
 }
 
 void test__RemoveDirectory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RemoveDirectory(p);
   // cppcheck-suppress memleak
 }
@@ -10998,7 +10986,7 @@ void test__RemoveDirectoryA__noreturn() {
 }
 
 void test__RemoveDirectoryA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RemoveDirectoryA(p);
   // cppcheck-suppress memleak
 }
@@ -11017,7 +11005,7 @@ void test__RemoveDirectoryW__noreturn() {
 }
 
 void test__RemoveDirectoryW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   RemoveDirectoryW(p);
   // cppcheck-suppress memleak
 }
@@ -11036,7 +11024,7 @@ void test____isascii__noreturn() {
 }
 
 void test____isascii__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   __isascii(p);
   // cppcheck-suppress memleak
 }
@@ -11055,7 +11043,7 @@ void test__iswascii__noreturn() {
 }
 
 void test__iswascii__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   iswascii(p);
   // cppcheck-suppress memleak
 }
@@ -11074,7 +11062,7 @@ void test___getchar__noreturn() {
 }
 
 void test___getchar__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _getchar();
   // cppcheck-suppress memleak
 }
@@ -11087,7 +11075,7 @@ void test___getch_nolock__noreturn() {
 }
 
 void test___getch_nolock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _getch_nolock();
   // cppcheck-suppress memleak
 }
@@ -11100,7 +11088,7 @@ void test___getwch__noreturn() {
 }
 
 void test___getwch__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _getwch();
   // cppcheck-suppress memleak
 }
@@ -11113,7 +11101,7 @@ void test___getwch_nolock__noreturn() {
 }
 
 void test___getwch_nolock__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   _getwch_nolock();
   // cppcheck-suppress memleak
 }
@@ -11126,7 +11114,7 @@ void test__Sleep__noreturn() {
 }
 
 void test__Sleep__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   Sleep(p);
   // cppcheck-suppress memleak
 }
@@ -11150,7 +11138,7 @@ void test__SleepEx__noreturn() {
 }
 
 void test__SleepEx__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SleepEx(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11299,7 +11287,7 @@ void test__GetModuleHandle__useretval() {
 }
 
 void test__GetModuleHandle__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetModuleHandle(p);
   // cppcheck-suppress memleak
 }
@@ -11323,7 +11311,7 @@ void test__GetModuleHandleA__useretval() {
 }
 
 void test__GetModuleHandleA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetModuleHandleA(p);
   // cppcheck-suppress memleak
 }
@@ -11347,7 +11335,7 @@ void test__GetModuleHandleW__useretval() {
 }
 
 void test__GetModuleHandleW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetModuleHandleW(p);
   // cppcheck-suppress memleak
 }
@@ -11493,7 +11481,7 @@ void test__GetProcAddress__useretval() {
 }
 
 void test__GetProcAddress__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = GetProcAddress(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -11913,7 +11901,7 @@ void test__PulseEvent__noreturn() {
 }
 
 void test__PulseEvent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   PulseEvent(p);
   // cppcheck-suppress memleak
 }
@@ -11938,7 +11926,7 @@ void test__ResetEvent__noreturn() {
 }
 
 void test__ResetEvent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ResetEvent(p);
   // cppcheck-suppress memleak
 }
@@ -11963,7 +11951,7 @@ void test__SetEvent__noreturn() {
 }
 
 void test__SetEvent__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetEvent(p);
   // cppcheck-suppress memleak
 }
@@ -12075,7 +12063,7 @@ void test__SetCriticalSectionSpinCount__noreturn() {
 }
 
 void test__SetCriticalSectionSpinCount__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetCriticalSectionSpinCount(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -12134,7 +12122,7 @@ void test__EnterCriticalSection__noreturn() {
 }
 
 void test__EnterCriticalSection__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   EnterCriticalSection(p);
   // cppcheck-suppress memleak
 }
@@ -12164,7 +12152,7 @@ void test__TryEnterCriticalSection__noreturn() {
 }
 
 void test__TryEnterCriticalSection__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   TryEnterCriticalSection(p);
   // cppcheck-suppress memleak
 }
@@ -12194,7 +12182,7 @@ void test__LeaveCriticalSection__noreturn() {
 }
 
 void test__LeaveCriticalSection__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   LeaveCriticalSection(p);
   // cppcheck-suppress memleak
 }
@@ -12224,7 +12212,7 @@ void test__lstrcat__noreturn() {
 }
 
 void test__lstrcat__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   lstrcat(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -12997,7 +12985,7 @@ void test__ReleaseMutex__noreturn() {
 }
 
 void test__ReleaseMutex__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ReleaseMutex(p);
   // cppcheck-suppress memleak
 }
@@ -13103,7 +13091,7 @@ void test__GetLocalTime__noreturn() {
 }
 
 void test__GetLocalTime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetLocalTime(p);
   // cppcheck-suppress memleak
 }
@@ -13122,7 +13110,7 @@ void test__GetSystemTime__noreturn() {
 }
 
 void test__GetSystemTime__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetSystemTime(p);
   // cppcheck-suppress memleak
 }
@@ -13153,7 +13141,7 @@ void test__SetLastError__noreturn() {
 }
 
 void test__SetLastError__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   SetLastError(p);
   // cppcheck-suppress memleak
 }
@@ -13302,7 +13290,7 @@ void test__HeapSize__useretval() {
 }
 
 void test__HeapSize__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = HeapSize(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13333,7 +13321,7 @@ void test__HeapValidate__noreturn() {
 }
 
 void test__HeapValidate__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   HeapValidate(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13376,7 +13364,7 @@ void test__GetUserName__noreturn() {
 }
 
 void test__GetUserName__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetUserName(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -13401,7 +13389,7 @@ void test__GetUserNameA__noreturn() {
 }
 
 void test__GetUserNameA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetUserNameA(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -13426,7 +13414,7 @@ void test__GetUserNameW__noreturn() {
 }
 
 void test__GetUserNameW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetUserNameW(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -13451,7 +13439,7 @@ void test__GetWindowText__noreturn() {
 }
 
 void test__GetWindowText__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetWindowText(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13482,7 +13470,7 @@ void test__GetWindowTextA__noreturn() {
 }
 
 void test__GetWindowTextA__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetWindowTextA(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13513,7 +13501,7 @@ void test__GetWindowTextW__noreturn() {
 }
 
 void test__GetWindowTextW__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   GetWindowTextW(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13582,7 +13570,7 @@ void test__accept__noreturn() {
 }
 
 void test__accept__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   accept(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13613,7 +13601,7 @@ void test__bind__noreturn() {
 }
 
 void test__bind__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   bind(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13644,7 +13632,7 @@ void test__connect__noreturn() {
 }
 
 void test__connect__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   connect(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13675,7 +13663,7 @@ void test__getpeername__noreturn() {
 }
 
 void test__getpeername__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getpeername(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13712,7 +13700,7 @@ void test__getsockname__noreturn() {
 }
 
 void test__getsockname__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getsockname(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13749,7 +13737,7 @@ void test__getsockopt__noreturn() {
 }
 
 void test__getsockopt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   getsockopt(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -13803,7 +13791,7 @@ void test__htonl__useretval() {
 }
 
 void test__htonl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = htonl(p);
   // cppcheck-suppress memleak
 }
@@ -13827,7 +13815,7 @@ void test__htons__useretval() {
 }
 
 void test__htons__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = htons(p);
   // cppcheck-suppress memleak
 }
@@ -13851,7 +13839,7 @@ void test__inet_addr__useretval() {
 }
 
 void test__inet_addr__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = inet_addr(p);
   // cppcheck-suppress memleak
 }
@@ -13881,7 +13869,7 @@ void test__inet_ntoa__useretval() {
 }
 
 void test__inet_ntoa__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = inet_ntoa(p);
   // cppcheck-suppress memleak
 }
@@ -13900,7 +13888,7 @@ void test__ioctlsocket__noreturn() {
 }
 
 void test__ioctlsocket__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   ioctlsocket(p, arg2, arg3);
   // cppcheck-suppress memleak
 }
@@ -13931,7 +13919,7 @@ void test__listen__noreturn() {
 }
 
 void test__listen__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   listen(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -13961,7 +13949,7 @@ void test__ntohl__useretval() {
 }
 
 void test__ntohl__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ntohl(p);
   // cppcheck-suppress memleak
 }
@@ -13985,7 +13973,7 @@ void test__ntohs__useretval() {
 }
 
 void test__ntohs__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = ntohs(p);
   // cppcheck-suppress memleak
 }
@@ -14004,7 +13992,7 @@ void test__recv__noreturn() {
 }
 
 void test__recv__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   recv(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -14041,7 +14029,7 @@ void test__recvfrom__noreturn() {
 }
 
 void test__recvfrom__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   recvfrom(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -14078,7 +14066,7 @@ void test__select__noreturn() {
 }
 
 void test__select__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   select(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -14097,7 +14085,7 @@ void test__send__noreturn() {
 }
 
 void test__send__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   send(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -14134,7 +14122,7 @@ void test__sendto__noreturn() {
 }
 
 void test__sendto__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   sendto(p, arg2, arg3, arg4, arg5, arg6);
   // cppcheck-suppress memleak
 }
@@ -14183,7 +14171,7 @@ void test__setsockopt__noreturn() {
 }
 
 void test__setsockopt__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   setsockopt(p, arg2, arg3, arg4, arg5);
   // cppcheck-suppress memleak
 }
@@ -14226,7 +14214,7 @@ void test__shutdown__noreturn() {
 }
 
 void test__shutdown__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   shutdown(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14251,7 +14239,7 @@ void test__WSAStartup__noreturn() {
 }
 
 void test__WSAStartup__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   WSAStartup(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14295,7 +14283,7 @@ void test__WSASetLastError__noreturn() {
 }
 
 void test__WSASetLastError__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   WSASetLastError(p);
   // cppcheck-suppress memleak
 }
@@ -14319,7 +14307,7 @@ void test___fileno__useretval() {
 }
 
 void test___fileno__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _fileno(p);
   // cppcheck-suppress memleak
 }
@@ -14354,7 +14342,7 @@ void test___tolower__useretval() {
 }
 
 void test___tolower__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tolower(p);
   // cppcheck-suppress memleak
 }
@@ -14378,7 +14366,7 @@ void test___tolower_l__useretval() {
 }
 
 void test___tolower_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _tolower_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14408,7 +14396,7 @@ void test___towlower_l__useretval() {
 }
 
 void test___towlower_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _towlower_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14438,7 +14426,7 @@ void test___toupper__useretval() {
 }
 
 void test___toupper__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _toupper(p);
   // cppcheck-suppress memleak
 }
@@ -14462,7 +14450,7 @@ void test___toupper_l__useretval() {
 }
 
 void test___toupper_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _toupper_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14492,7 +14480,7 @@ void test___towupper_l__useretval() {
 }
 
 void test___towupper_l__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = _towupper_l(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -14517,7 +14505,7 @@ void test____noop__noreturn() {
 }
 
 void test____noop__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   __noop();
   // cppcheck-suppress memleak
 }
diff --git a/test/cfg/generated-cfg-tests-wxwidgets.cpp b/test/cfg/generated-cfg-tests-wxwidgets.cpp
index ccd7816dc..1c4545877 100644
--- a/test/cfg/generated-cfg-tests-wxwidgets.cpp
+++ b/test/cfg/generated-cfg-tests-wxwidgets.cpp
@@ -15,12 +15,6 @@ void test__wxString__Format__noreturn() {
   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);
@@ -45,12 +39,6 @@ void test__wxString__Printf__noreturn() {
   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);
@@ -80,12 +68,6 @@ void test__wxString__IsEmpty__useretval() {
   wxString::IsEmpty();
 }
 
-void test__wxString__IsEmpty__leakignore() {
-  char *p = strdup(str);
-  result = wxString::IsEmpty();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__IsNull__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::IsNull(); }
@@ -98,12 +80,6 @@ void test__wxString__IsNull__useretval() {
   wxString::IsNull();
 }
 
-void test__wxString__IsNull__leakignore() {
-  char *p = strdup(str);
-  result = wxString::IsNull();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__IsNumber__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::IsNumber(); }
@@ -116,12 +92,6 @@ void test__wxString__IsNumber__useretval() {
   wxString::IsNumber();
 }
 
-void test__wxString__IsNumber__leakignore() {
-  char *p = strdup(str);
-  result = wxString::IsNumber();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__IsAscii__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::IsAscii(); }
@@ -134,12 +104,6 @@ void test__wxString__IsAscii__useretval() {
   wxString::IsAscii();
 }
 
-void test__wxString__IsAscii__leakignore() {
-  char *p = strdup(str);
-  result = wxString::IsAscii();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__IsWord__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::IsWord(); }
@@ -152,12 +116,6 @@ void test__wxString__IsWord__useretval() {
   wxString::IsWord();
 }
 
-void test__wxString__IsWord__leakignore() {
-  char *p = strdup(str);
-  result = wxString::IsWord();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__Len__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::Len(); }
@@ -170,12 +128,6 @@ void test__wxString__Len__useretval() {
   wxString::Len();
 }
 
-void test__wxString__Len__leakignore() {
-  char *p = strdup(str);
-  result = wxString::Len();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__length__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::length(); }
@@ -188,12 +140,6 @@ void test__wxString__length__useretval() {
   wxString::length();
 }
 
-void test__wxString__length__leakignore() {
-  char *p = strdup(str);
-  result = wxString::length();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__Length__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::Length(); }
@@ -206,12 +152,6 @@ void test__wxString__Length__useretval() {
   wxString::Length();
 }
 
-void test__wxString__Length__leakignore() {
-  char *p = strdup(str);
-  result = wxString::Length();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__Lower__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::Lower(); }
@@ -224,12 +164,6 @@ void test__wxString__Lower__useretval() {
   wxString::Lower();
 }
 
-void test__wxString__Lower__leakignore() {
-  char *p = strdup(str);
-  result = wxString::Lower();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__MakeCapitalized__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::MakeCapitalized(); }
@@ -242,12 +176,6 @@ void test__wxString__MakeCapitalized__useretval() {
   wxString::MakeCapitalized();
 }
 
-void test__wxString__MakeCapitalized__leakignore() {
-  char *p = strdup(str);
-  result = wxString::MakeCapitalized();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__MakeLower__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::MakeLower(); }
@@ -260,12 +188,6 @@ void test__wxString__MakeLower__useretval() {
   wxString::MakeLower();
 }
 
-void test__wxString__MakeLower__leakignore() {
-  char *p = strdup(str);
-  result = wxString::MakeLower();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__MakeUpper__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::MakeUpper(); }
@@ -278,12 +200,6 @@ void test__wxString__MakeUpper__useretval() {
   wxString::MakeUpper();
 }
 
-void test__wxString__MakeUpper__leakignore() {
-  char *p = strdup(str);
-  result = wxString::MakeUpper();
-  // cppcheck-suppress memleak
-}
-
 void test__wxString__Matches__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxString::Matches(arg1); }
@@ -296,12 +212,6 @@ void test__wxString__Matches__useretval() {
   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
@@ -315,12 +225,6 @@ void test__wxString__LowerCase__noreturn() {
   x = 1 << x;
 }
 
-void test__wxString__LowerCase__leakignore() {
-  char *p = strdup(str);
-  wxString::LowerCase();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSysErrorCode__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSysErrorCode(); }
@@ -341,7 +245,7 @@ void test__wxLogMessage__noreturn() {
 }
 
 void test__wxLogMessage__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogMessage(p);
   // cppcheck-suppress memleak
 }
@@ -371,7 +275,7 @@ void test__wxLogVerbose__noreturn() {
 }
 
 void test__wxLogVerbose__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogVerbose(p);
   // cppcheck-suppress memleak
 }
@@ -401,7 +305,7 @@ void test__wxLogWarning__noreturn() {
 }
 
 void test__wxLogWarning__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogWarning(p);
   // cppcheck-suppress memleak
 }
@@ -431,7 +335,7 @@ void test__wxLogFatalError__noreturn() {
 }
 
 void test__wxLogFatalError__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogFatalError(p);
   // cppcheck-suppress memleak
 }
@@ -461,7 +365,7 @@ void test__wxLogError__noreturn() {
 }
 
 void test__wxLogError__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogError(p);
   // cppcheck-suppress memleak
 }
@@ -491,7 +395,7 @@ void test__wxLogTrace__noreturn() {
 }
 
 void test__wxLogTrace__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogTrace(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -521,7 +425,7 @@ void test__wxLogDebug__noreturn() {
 }
 
 void test__wxLogDebug__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogDebug(p);
   // cppcheck-suppress memleak
 }
@@ -551,7 +455,7 @@ void test__wxLogSysError__noreturn() {
 }
 
 void test__wxLogSysError__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogSysError(p);
   // cppcheck-suppress memleak
 }
@@ -581,7 +485,7 @@ void test__wxLogGeneric__noreturn() {
 }
 
 void test__wxLogGeneric__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogGeneric(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -617,7 +521,7 @@ void test__wxLogInfo__noreturn() {
 }
 
 void test__wxLogInfo__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLogInfo(p);
   // cppcheck-suppress memleak
 }
@@ -651,12 +555,6 @@ void test__wxSpinCtrl__GetMax__useretval() {
   wxSpinCtrl::GetMax();
 }
 
-void test__wxSpinCtrl__GetMax__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrl::GetMax();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrl__GetMin__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrl::GetMin(); }
@@ -669,12 +567,6 @@ void test__wxSpinCtrl__GetMin__useretval() {
   wxSpinCtrl::GetMin();
 }
 
-void test__wxSpinCtrl__GetMin__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrl::GetMin();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrl__GetBase__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrl::GetBase(); }
@@ -687,12 +579,6 @@ void test__wxSpinCtrl__GetBase__useretval() {
   wxSpinCtrl::GetBase();
 }
 
-void test__wxSpinCtrl__GetBase__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrl::GetBase();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrl__GetValue__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrl::GetValue(); }
@@ -705,12 +591,6 @@ void test__wxSpinCtrl__GetValue__useretval() {
   wxSpinCtrl::GetValue();
 }
 
-void test__wxSpinCtrl__GetValue__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrl::GetValue();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrl__SetBase__noreturn() {
   int x = 1;
   if (cond) { x=100; wxSpinCtrl::SetBase(arg1); }
@@ -723,12 +603,6 @@ void test__wxSpinCtrl__SetBase__pure(int arg1) {
   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);
@@ -752,12 +626,6 @@ void test__wxSpinCtrlDouble__GetDigits__useretval() {
   wxSpinCtrlDouble::GetDigits();
 }
 
-void test__wxSpinCtrlDouble__GetDigits__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrlDouble::GetDigits();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrlDouble__GetIncrement__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrlDouble::GetIncrement(); }
@@ -770,12 +638,6 @@ void test__wxSpinCtrlDouble__GetIncrement__useretval() {
   wxSpinCtrlDouble::GetIncrement();
 }
 
-void test__wxSpinCtrlDouble__GetIncrement__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrlDouble::GetIncrement();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrlDouble__GetMax__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrlDouble::GetMax(); }
@@ -788,12 +650,6 @@ void test__wxSpinCtrlDouble__GetMax__useretval() {
   wxSpinCtrlDouble::GetMax();
 }
 
-void test__wxSpinCtrlDouble__GetMax__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrlDouble::GetMax();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrlDouble__GetMin__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrlDouble::GetMin(); }
@@ -806,12 +662,6 @@ void test__wxSpinCtrlDouble__GetMin__useretval() {
   wxSpinCtrlDouble::GetMin();
 }
 
-void test__wxSpinCtrlDouble__GetMin__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrlDouble::GetMin();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrlDouble__GetValue__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSpinCtrlDouble::GetValue(); }
@@ -824,12 +674,6 @@ void test__wxSpinCtrlDouble__GetValue__useretval() {
   wxSpinCtrlDouble::GetValue();
 }
 
-void test__wxSpinCtrlDouble__GetValue__leakignore() {
-  char *p = strdup(str);
-  result = wxSpinCtrlDouble::GetValue();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSpinCtrlDouble__SetDigits__noreturn() {
   int x = 1;
   if (cond) { x=100; wxSpinCtrlDouble::SetDigits(arg1); }
@@ -837,12 +681,6 @@ void test__wxSpinCtrlDouble__SetDigits__noreturn() {
   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
@@ -856,12 +694,6 @@ void test__wxSpinCtrlDouble__SetIncrement__noreturn() {
   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
@@ -875,12 +707,6 @@ void test__wxSpinCtrlDouble__SetRange__noreturn() {
   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
@@ -900,12 +726,6 @@ void test__wxSpinCtrlDouble__SetValue__noreturn() {
   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
@@ -924,12 +744,6 @@ void test__wxSlider__GetLineSize__useretval() {
   wxSlider::GetLineSize();
 }
 
-void test__wxSlider__GetLineSize__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetLineSize();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetMax__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetMax(); }
@@ -942,12 +756,6 @@ void test__wxSlider__GetMax__useretval() {
   wxSlider::GetMax();
 }
 
-void test__wxSlider__GetMax__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetMax();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetMin__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetMin(); }
@@ -960,12 +768,6 @@ void test__wxSlider__GetMin__useretval() {
   wxSlider::GetMin();
 }
 
-void test__wxSlider__GetMin__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetMin();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetPageSize__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetPageSize(); }
@@ -978,12 +780,6 @@ void test__wxSlider__GetPageSize__useretval() {
   wxSlider::GetPageSize();
 }
 
-void test__wxSlider__GetPageSize__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetPageSize();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetSelEnd__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetSelEnd(); }
@@ -996,12 +792,6 @@ void test__wxSlider__GetSelEnd__useretval() {
   wxSlider::GetSelEnd();
 }
 
-void test__wxSlider__GetSelEnd__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetSelEnd();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetSelStart__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetSelStart(); }
@@ -1014,12 +804,6 @@ void test__wxSlider__GetSelStart__useretval() {
   wxSlider::GetSelStart();
 }
 
-void test__wxSlider__GetSelStart__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetSelStart();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetThumbLength__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetThumbLength(); }
@@ -1032,12 +816,6 @@ void test__wxSlider__GetThumbLength__useretval() {
   wxSlider::GetThumbLength();
 }
 
-void test__wxSlider__GetThumbLength__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetThumbLength();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetTickFreq__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetTickFreq(); }
@@ -1050,12 +828,6 @@ void test__wxSlider__GetTickFreq__useretval() {
   wxSlider::GetTickFreq();
 }
 
-void test__wxSlider__GetTickFreq__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetTickFreq();
-  // cppcheck-suppress memleak
-}
-
 void test__wxSlider__GetValue__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxSlider::GetValue(); }
@@ -1068,12 +840,6 @@ void test__wxSlider__GetValue__useretval() {
   wxSlider::GetValue();
 }
 
-void test__wxSlider__GetValue__leakignore() {
-  char *p = strdup(str);
-  result = wxSlider::GetValue();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__GetId__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTimer::GetId(); }
@@ -1086,12 +852,6 @@ void test__wxTimer__GetId__useretval() {
   wxTimer::GetId();
 }
 
-void test__wxTimer__GetId__leakignore() {
-  char *p = strdup(str);
-  result = wxTimer::GetId();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__GetInterval__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTimer::GetInterval(); }
@@ -1104,12 +864,6 @@ void test__wxTimer__GetInterval__useretval() {
   wxTimer::GetInterval();
 }
 
-void test__wxTimer__GetInterval__leakignore() {
-  char *p = strdup(str);
-  result = wxTimer::GetInterval();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__GetOwner__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTimer::GetOwner(); }
@@ -1122,12 +876,6 @@ void test__wxTimer__GetOwner__useretval() {
   wxTimer::GetOwner();
 }
 
-void test__wxTimer__GetOwner__leakignore() {
-  char *p = strdup(str);
-  result = wxTimer::GetOwner();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__IsOneShot__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTimer::IsOneShot(); }
@@ -1140,12 +888,6 @@ void test__wxTimer__IsOneShot__useretval() {
   wxTimer::IsOneShot();
 }
 
-void test__wxTimer__IsOneShot__leakignore() {
-  char *p = strdup(str);
-  result = wxTimer::IsOneShot();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__IsRunning__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTimer::IsRunning(); }
@@ -1158,12 +900,6 @@ void test__wxTimer__IsRunning__useretval() {
   wxTimer::IsRunning();
 }
 
-void test__wxTimer__IsRunning__leakignore() {
-  char *p = strdup(str);
-  result = wxTimer::IsRunning();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__Notify__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTimer::Notify(); }
@@ -1171,12 +907,6 @@ void test__wxTimer__Notify__noreturn() {
   x = 1 << x;
 }
 
-void test__wxTimer__Notify__leakignore() {
-  char *p = strdup(str);
-  wxTimer::Notify();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTimer__SetOwner__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTimer::SetOwner(arg1, arg2); }
@@ -1184,12 +914,6 @@ void test__wxTimer__SetOwner__noreturn() {
   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() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -1215,12 +939,6 @@ void test__wxTimer__Start__noreturn() {
   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
@@ -1240,12 +958,6 @@ void test__wxTimer__StartOnce__noreturn() {
   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
@@ -1259,12 +971,6 @@ void test__wxTimer__Stop__noreturn() {
   x = 1 << x;
 }
 
-void test__wxTimer__Stop__leakignore() {
-  char *p = strdup(str);
-  wxTimer::Stop();
-  // cppcheck-suppress memleak
-}
-
 void test__wxRadioBox__Enable__noreturn() {
   int x = 1;
   if (cond) { x=100; wxRadioBox::Enable(arg1, arg2); }
@@ -1272,12 +978,6 @@ void test__wxRadioBox__Enable__noreturn() {
   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
@@ -1297,12 +997,6 @@ void test__wxRadioBox__FindString__noreturn() {
   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
@@ -1327,12 +1021,6 @@ void test__wxRadioBox__GetColumnCount__useretval() {
   wxRadioBox::GetColumnCount();
 }
 
-void test__wxRadioBox__GetColumnCount__leakignore() {
-  char *p = strdup(str);
-  result = wxRadioBox::GetColumnCount();
-  // cppcheck-suppress memleak
-}
-
 void test__wxRadioBox__GetItemFromPoint__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxRadioBox::GetItemFromPoint(arg1); }
@@ -1345,12 +1033,6 @@ void test__wxRadioBox__GetItemFromPoint__useretval() {
   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
@@ -1369,12 +1051,6 @@ void test__wxRadioBox__GetItemHelpText__useretval() {
   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
@@ -1393,12 +1069,6 @@ void test__wxRadioBox__GetItemToolTip__useretval() {
   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
@@ -1412,12 +1082,6 @@ void test__wxRadioBox__GetRowCount__noreturn() {
   x = 1 << x;
 }
 
-void test__wxRadioBox__GetRowCount__leakignore() {
-  char *p = strdup(str);
-  wxRadioBox::GetRowCount();
-  // cppcheck-suppress memleak
-}
-
 void test__wxRadioBox__IsItemEnabled__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxRadioBox::IsItemEnabled(arg1); }
@@ -1430,12 +1094,6 @@ void test__wxRadioBox__IsItemEnabled__useretval() {
   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
@@ -1454,12 +1112,6 @@ void test__wxRadioBox__IsItemShown__useretval() {
   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
@@ -1473,12 +1125,6 @@ void test__wxRadioBox__SetItemHelpText__noreturn() {
   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
@@ -1498,12 +1144,6 @@ void test__wxRadioBox__SetItemToolTip__noreturn() {
   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
@@ -1523,12 +1163,6 @@ void test__wxRadioBox__SetSelection__noreturn() {
   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
@@ -1542,12 +1176,6 @@ void test__wxRadioBox__Show__noreturn() {
   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
@@ -1572,12 +1200,6 @@ void test__wxRadioBox__GetCount__useretval() {
   wxRadioBox::GetCount();
 }
 
-void test__wxRadioBox__GetCount__leakignore() {
-  char *p = strdup(str);
-  result = wxRadioBox::GetCount();
-  // cppcheck-suppress memleak
-}
-
 void test__wxRadioBox__GetString__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxRadioBox::GetString(arg1); }
@@ -1590,12 +1212,6 @@ void test__wxRadioBox__GetString__useretval() {
   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
@@ -1609,12 +1225,6 @@ void test__wxRadioBox__SetString__noreturn() {
   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
@@ -1639,12 +1249,6 @@ void test__wxRadioBox__GetSelection__useretval() {
   wxRadioBox::GetSelection();
 }
 
-void test__wxRadioBox__GetSelection__leakignore() {
-  char *p = strdup(str);
-  result = wxRadioBox::GetSelection();
-  // cppcheck-suppress memleak
-}
-
 void test__wxButton__GetAuthNeeded__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxButton::GetAuthNeeded(); }
@@ -1657,12 +1261,6 @@ void test__wxButton__GetAuthNeeded__useretval() {
   wxButton::GetAuthNeeded();
 }
 
-void test__wxButton__GetAuthNeeded__leakignore() {
-  char *p = strdup(str);
-  result = wxButton::GetAuthNeeded();
-  // cppcheck-suppress memleak
-}
-
 void test__wxButton__GetLabel__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxButton::GetLabel(); }
@@ -1675,12 +1273,6 @@ void test__wxButton__GetLabel__useretval() {
   wxButton::GetLabel();
 }
 
-void test__wxButton__GetLabel__leakignore() {
-  char *p = strdup(str);
-  result = wxButton::GetLabel();
-  // cppcheck-suppress memleak
-}
-
 void test__wxButton__SetAuthNeeded__noreturn() {
   int x = 1;
   if (cond) { x=100; wxButton::SetAuthNeeded(arg1); }
@@ -1688,12 +1280,6 @@ void test__wxButton__SetAuthNeeded__noreturn() {
   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
@@ -1707,12 +1293,6 @@ void test__wxButton__SetDefault__noreturn() {
   x = 1 << x;
 }
 
-void test__wxButton__SetDefault__leakignore() {
-  char *p = strdup(str);
-  wxButton::SetDefault();
-  // cppcheck-suppress memleak
-}
-
 void test__wxButton__SetLabel__noreturn() {
   int x = 1;
   if (cond) { x=100; wxButton::SetLabel(arg1); }
@@ -1720,12 +1300,6 @@ void test__wxButton__SetLabel__noreturn() {
   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
@@ -1744,12 +1318,6 @@ void test__wxColour__Alpha__useretval() {
   wxColour::Alpha();
 }
 
-void test__wxColour__Alpha__leakignore() {
-  char *p = strdup(str);
-  result = wxColour::Alpha();
-  // cppcheck-suppress memleak
-}
-
 void test__wxColour__Blue__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxColour::Blue(); }
@@ -1762,12 +1330,6 @@ void test__wxColour__Blue__useretval() {
   wxColour::Blue();
 }
 
-void test__wxColour__Blue__leakignore() {
-  char *p = strdup(str);
-  result = wxColour::Blue();
-  // cppcheck-suppress memleak
-}
-
 void test__wxColour__Green__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxColour::Green(); }
@@ -1780,12 +1342,6 @@ void test__wxColour__Green__useretval() {
   wxColour::Green();
 }
 
-void test__wxColour__Green__leakignore() {
-  char *p = strdup(str);
-  result = wxColour::Green();
-  // cppcheck-suppress memleak
-}
-
 void test__wxColour__Red__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxColour::Red(); }
@@ -1798,12 +1354,6 @@ void test__wxColour__Red__useretval() {
   wxColour::Red();
 }
 
-void test__wxColour__Red__leakignore() {
-  char *p = strdup(str);
-  result = wxColour::Red();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__AddLine__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::AddLine(arg1, arg2); }
@@ -1811,12 +1361,6 @@ void test__wxTextFile__AddLine__noreturn() {
   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
@@ -1836,12 +1380,6 @@ void test__wxTextFile__Clear__noreturn() {
   x = 1 << x;
 }
 
-void test__wxTextFile__Clear__leakignore() {
-  char *p = strdup(str);
-  wxTextFile::Clear();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__Close__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::Close(); }
@@ -1849,12 +1387,6 @@ void test__wxTextFile__Close__noreturn() {
   x = 1 << x;
 }
 
-void test__wxTextFile__Close__leakignore() {
-  char *p = strdup(str);
-  wxTextFile::Close();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__Create__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::Create(arg1); }
@@ -1862,12 +1394,6 @@ void test__wxTextFile__Create__noreturn() {
   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
@@ -1886,12 +1412,6 @@ void test__wxTextFile__Eof__useretval() {
   wxTextFile::Eof();
 }
 
-void test__wxTextFile__Eof__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::Eof();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__Exists__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::Exists(); }
@@ -1904,12 +1424,6 @@ void test__wxTextFile__Exists__useretval() {
   wxTextFile::Exists();
 }
 
-void test__wxTextFile__Exists__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::Exists();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetCurrentLine__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetCurrentLine(); }
@@ -1922,12 +1436,6 @@ void test__wxTextFile__GetCurrentLine__useretval() {
   wxTextFile::GetCurrentLine();
 }
 
-void test__wxTextFile__GetCurrentLine__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetCurrentLine();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetFirstLine__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetFirstLine(); }
@@ -1940,12 +1448,6 @@ void test__wxTextFile__GetFirstLine__useretval() {
   wxTextFile::GetFirstLine();
 }
 
-void test__wxTextFile__GetFirstLine__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetFirstLine();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetLastLine__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetLastLine(); }
@@ -1958,12 +1460,6 @@ void test__wxTextFile__GetLastLine__useretval() {
   wxTextFile::GetLastLine();
 }
 
-void test__wxTextFile__GetLastLine__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetLastLine();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetLineCount__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetLineCount(); }
@@ -1976,12 +1472,6 @@ void test__wxTextFile__GetLineCount__useretval() {
   wxTextFile::GetLineCount();
 }
 
-void test__wxTextFile__GetLineCount__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetLineCount();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetLineType__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetLineType(); }
@@ -1994,12 +1484,6 @@ void test__wxTextFile__GetLineType__useretval() {
   wxTextFile::GetLineType();
 }
 
-void test__wxTextFile__GetLineType__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetLineType();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetName__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetName(); }
@@ -2012,12 +1496,6 @@ void test__wxTextFile__GetName__useretval() {
   wxTextFile::GetName();
 }
 
-void test__wxTextFile__GetName__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetName();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetNextLine__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetNextLine(); }
@@ -2030,12 +1508,6 @@ void test__wxTextFile__GetNextLine__useretval() {
   wxTextFile::GetNextLine();
 }
 
-void test__wxTextFile__GetNextLine__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetNextLine();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GetPrevLine__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxTextFile::GetPrevLine(); }
@@ -2048,12 +1520,6 @@ void test__wxTextFile__GetPrevLine__useretval() {
   wxTextFile::GetPrevLine();
 }
 
-void test__wxTextFile__GetPrevLine__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GetPrevLine();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__GoToLine__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::GoToLine(arg1); }
@@ -2061,12 +1527,6 @@ void test__wxTextFile__GoToLine__noreturn() {
   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
@@ -2085,12 +1545,6 @@ void test__wxTextFile__GuessType__useretval() {
   wxTextFile::GuessType();
 }
 
-void test__wxTextFile__GuessType__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::GuessType();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__InsertLine__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::InsertLine(arg1, arg2, arg3); }
@@ -2098,12 +1552,6 @@ void test__wxTextFile__InsertLine__noreturn() {
   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
@@ -2134,12 +1582,6 @@ void test__wxTextFile__IsOpened__useretval() {
   wxTextFile::IsOpened();
 }
 
-void test__wxTextFile__IsOpened__leakignore() {
-  char *p = strdup(str);
-  result = wxTextFile::IsOpened();
-  // cppcheck-suppress memleak
-}
-
 void test__wxTextFile__RemoveLine__noreturn() {
   int x = 1;
   if (cond) { x=100; wxTextFile::RemoveLine(arg1); }
@@ -2147,12 +1589,6 @@ void test__wxTextFile__RemoveLine__noreturn() {
   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
@@ -2171,12 +1607,6 @@ void test__wxTextFile__GetLine__useretval() {
   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
@@ -2190,12 +1620,6 @@ void test__wxSizer__AddSpacer__noreturn() {
   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
@@ -2209,12 +1633,6 @@ void test__wxBoxSizer__AddSpacer__noreturn() {
   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
@@ -2228,12 +1646,6 @@ void test__wxBoxSizer__CalcMin__noreturn() {
   x = 1 << x;
 }
 
-void test__wxBoxSizer__CalcMin__leakignore() {
-  char *p = strdup(str);
-  wxBoxSizer::CalcMin();
-  // cppcheck-suppress memleak
-}
-
 void test__wxBoxSizer__GetOrientation__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxBoxSizer::GetOrientation(); }
@@ -2246,12 +1658,6 @@ void test__wxBoxSizer__GetOrientation__useretval() {
   wxBoxSizer::GetOrientation();
 }
 
-void test__wxBoxSizer__GetOrientation__leakignore() {
-  char *p = strdup(str);
-  result = wxBoxSizer::GetOrientation();
-  // cppcheck-suppress memleak
-}
-
 void test__wxBoxSizer__RecalcSizes__noreturn() {
   int x = 1;
   if (cond) { x=100; wxBoxSizer::RecalcSizes(); }
@@ -2259,12 +1665,6 @@ void test__wxBoxSizer__RecalcSizes__noreturn() {
   x = 1 << x;
 }
 
-void test__wxBoxSizer__RecalcSizes__leakignore() {
-  char *p = strdup(str);
-  wxBoxSizer::RecalcSizes();
-  // cppcheck-suppress memleak
-}
-
 void test__wxBoxSizer__SetOrientation__noreturn() {
   int x = 1;
   if (cond) { x=100; wxBoxSizer::SetOrientation(arg1); }
@@ -2272,12 +1672,6 @@ void test__wxBoxSizer__SetOrientation__noreturn() {
   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
@@ -2291,12 +1685,6 @@ void test__wxStaticBoxSizer__CalcMin__noreturn() {
   x = 1 << x;
 }
 
-void test__wxStaticBoxSizer__CalcMin__leakignore() {
-  char *p = strdup(str);
-  wxStaticBoxSizer::CalcMin();
-  // cppcheck-suppress memleak
-}
-
 void test__wxStaticBoxSizer__GetStaticBox__noreturn() {
   int x = 1;
   if (cond) { x=100; result = wxStaticBoxSizer::GetStaticBox(); }
@@ -2309,12 +1697,6 @@ void test__wxStaticBoxSizer__GetStaticBox__useretval() {
   wxStaticBoxSizer::GetStaticBox();
 }
 
-void test__wxStaticBoxSizer__GetStaticBox__leakignore() {
-  char *p = strdup(str);
-  result = wxStaticBoxSizer::GetStaticBox();
-  // cppcheck-suppress memleak
-}
-
 void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
   int x = 1;
   if (cond) { x=100; wxStaticBoxSizer::RecalcSizes(); }
@@ -2322,12 +1704,6 @@ void test__wxStaticBoxSizer__RecalcSizes__noreturn() {
   x = 1 << x;
 }
 
-void test__wxStaticBoxSizer__RecalcSizes__leakignore() {
-  char *p = strdup(str);
-  wxStaticBoxSizer::RecalcSizes();
-  // cppcheck-suppress memleak
-}
-
 void test__wxMenu__Append__noreturn() {
   int x = 1;
   if (cond) { x=100; wxMenu::Append(arg1, arg2, arg3, arg4); }
@@ -2335,12 +1711,6 @@ void test__wxMenu__Append__noreturn() {
   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
@@ -2361,7 +1731,7 @@ void test__wxLaunchDefaultBrowser__noreturn() {
 }
 
 void test__wxLaunchDefaultBrowser__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxLaunchDefaultBrowser(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2391,7 +1761,7 @@ void test__wxDirExists__useretval() {
 }
 
 void test__wxDirExists__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wxDirExists(p);
   // cppcheck-suppress memleak
 }
@@ -2415,7 +1785,7 @@ void test__wxFileExists__useretval() {
 }
 
 void test__wxFileExists__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wxFileExists(p);
   // cppcheck-suppress memleak
 }
@@ -2459,7 +1829,7 @@ void test__wxSetWorkingDirectory__noreturn() {
 }
 
 void test__wxSetWorkingDirectory__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxSetWorkingDirectory(p);
   // cppcheck-suppress memleak
 }
@@ -2478,7 +1848,7 @@ void test__wxMkdir__noreturn() {
 }
 
 void test__wxMkdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxMkdir(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2503,7 +1873,7 @@ void test__wxRmdir__noreturn() {
 }
 
 void test__wxRmdir__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxRmdir(p, arg2);
   // cppcheck-suppress memleak
 }
@@ -2533,7 +1903,7 @@ void test__wxGetTranslation__useretval() {
 }
 
 void test__wxGetTranslation__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wxGetTranslation(p, arg2, arg3, arg4);
   // cppcheck-suppress memleak
 }
@@ -2569,12 +1939,6 @@ void test__wxApp__MacOpenFile__noreturn() {
   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
@@ -2588,12 +1952,6 @@ void test__wxArtProvider__Insert__noreturn() {
   x = 1 << x;
 }
 
-void test__wxArtProvider__Insert__leakignore() {
-  char *p = strdup(str);
-  wxArtProvider::Insert(p);
-  // cppcheck-suppress memleak
-}
-
 void test__wxArtProvider__Insert__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2613,12 +1971,6 @@ void test__wxCalendarCtrl__EnableYearChange__noreturn() {
   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
@@ -2637,12 +1989,6 @@ void test__wxComboCtrl__GetTextIndent__useretval() {
   wxComboCtrl::GetTextIndent();
 }
 
-void test__wxComboCtrl__GetTextIndent__leakignore() {
-  char *p = strdup(str);
-  result = wxComboCtrl::GetTextIndent();
-  // cppcheck-suppress memleak
-}
-
 void test__wxComboCtrl__HidePopup__noreturn() {
   int x = 1;
   if (cond) { x=100; wxComboCtrl::HidePopup(arg1); }
@@ -2650,12 +1996,6 @@ void test__wxComboCtrl__HidePopup__noreturn() {
   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
@@ -2669,12 +2009,6 @@ void test__wxComboCtrl__ShowPopup__noreturn() {
   x = 1 << x;
 }
 
-void test__wxComboCtrl__ShowPopup__leakignore() {
-  char *p = strdup(str);
-  wxComboCtrl::ShowPopup();
-  // cppcheck-suppress memleak
-}
-
 void test__wxComboCtrl__SetTextIndent__noreturn() {
   int x = 1;
   if (cond) { x=100; wxComboCtrl::SetTextIndent(arg1); }
@@ -2682,12 +2016,6 @@ void test__wxComboCtrl__SetTextIndent__noreturn() {
   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
@@ -2701,12 +2029,6 @@ void test__wxDataViewCustomRenderer__Activate__noreturn() {
   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
@@ -2738,12 +2060,6 @@ void test__wxDataViewCustomRenderer__LeftClick__noreturn() {
   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
@@ -2786,12 +2102,6 @@ void test__wxDebugContext__GetLevel__useretval() {
   wxDebugContext::GetLevel();
 }
 
-void test__wxDebugContext__GetLevel__leakignore() {
-  char *p = strdup(str);
-  result = wxDebugContext::GetLevel();
-  // cppcheck-suppress memleak
-}
-
 void test__wxDebugContext__SetLevel__noreturn() {
   int x = 1;
   if (cond) { x=100; wxDebugContext::SetLevel(arg1); }
@@ -2799,12 +2109,6 @@ void test__wxDebugContext__SetLevel__noreturn() {
   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
@@ -2819,7 +2123,7 @@ void test__wxDos2UnixFilename__noreturn() {
 }
 
 void test__wxDos2UnixFilename__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   wxDos2UnixFilename(p);
   // cppcheck-suppress memleak
 }
@@ -2849,7 +2153,7 @@ void test__wxFileNameFromPath__useretval() {
 }
 
 void test__wxFileNameFromPath__leakignore() {
-  char *p = strdup(str);
+  char *p = malloc(10); *p=0;
   result = wxFileNameFromPath(p);
   // cppcheck-suppress memleak
 }
@@ -2867,12 +2171,6 @@ void test__wxSizerItem__SetWindow__noreturn() {
   x = 1 << x;
 }
 
-void test__wxSizerItem__SetWindow__leakignore() {
-  char *p = strdup(str);
-  wxSizerItem::SetWindow(p);
-  // cppcheck-suppress memleak
-}
-
 void test__wxSizerItem__SetWindow__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2892,12 +2190,6 @@ void test__wxSizerItem__SetSizer__noreturn() {
   x = 1 << x;
 }
 
-void test__wxSizerItem__SetSizer__leakignore() {
-  char *p = strdup(str);
-  wxSizerItem::SetSizer(p);
-  // cppcheck-suppress memleak
-}
-
 void test__wxSizerItem__SetSizer__arg1__notnull() {
   const char *p = NULL;
   // cppcheck-suppress nullPointer
@@ -2917,12 +2209,6 @@ void test__wxSizerItem__SetSpacer__noreturn() {
   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
@@ -2936,12 +2222,6 @@ void test__wxGrid__SetCellAlignment__noreturn() {
   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
@@ -2967,12 +2247,6 @@ void test__wxGrid__SetCellTextColour__noreturn() {
   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
diff --git a/tools/generate_cfg_tests.cpp b/tools/generate_cfg_tests.cpp
index cb96a07a6..ab5a0bb1e 100644
--- a/tools/generate_cfg_tests.cpp
+++ b/tools/generate_cfg_tests.cpp
@@ -157,9 +157,9 @@ static void testfunction(const tinyxml2::XMLElement *node, const std::string &fu
         std::cout << functionCall(functionName, false, -1, numberOfArgs, "") <<  " < 100)) {}" << std::endl;
         std::cout << "}" << std::endl << std::endl;
     }
-    if (leakignore) {
+    if (leakignore && functionName.find("::") == std::string::npos) {
         std::cout << "void test__" << replaceCharInString(functionName,':','_') << "__leakignore() {" << std::endl;
-        std::cout << "  char *p = strdup(str);" << std::endl;
+        std::cout << "  char *p = malloc(10); *p=0;" << std::endl;
         std::cout << "  " << functionCall(functionName, useretval, 1, numberOfArgs, "p") << ';' << std::endl;
         std::cout << "  // cppcheck-suppress memleak" << std::endl;
         std::cout << "}" << std::endl << std::endl;