int
main (int argc,
char *argv[])
{
test_sprintf ();
test_vsprintf ();
test_strdup ();
test_strndup ();
test_strcat ();
test_strncat ();
test_strcat_sprintf ();
test_strcat_vsprintf ();
test_str_split ();
test_array_new ();
test_array_add ();
test_array_addn ();
test_array_addp ();
test_array_copy ();
test_array_append ();
test_str_wrap ();
test_str_screen_width ();
test_str_screen_wrap ();
return 0;
}
bool torture_local_replace(struct torture_context *ctx)
{
bool ret = true;
ret &= test_ftruncate();
ret &= test_strlcpy();
ret &= test_strlcat();
ret &= test_mktime();
ret &= test_initgroups();
ret &= test_memmove();
ret &= test_strdup();
ret &= test_setlinebuf();
ret &= test_vsyslog();
ret &= test_timegm();
ret &= test_setenv();
ret &= test_strndup();
ret &= test_strnlen();
ret &= test_waitpid();
ret &= test_seteuid();
ret &= test_setegid();
ret &= test_asprintf();
ret &= test_snprintf();
ret &= test_vasprintf();
ret &= test_vsnprintf();
ret &= test_opendir();
ret &= test_readdir();
ret &= test_telldir();
ret &= test_seekdir();
ret &= test_dlopen();
ret &= test_chroot();
ret &= test_bzero();
ret &= test_strerror();
ret &= test_errno();
ret &= test_mkdtemp();
ret &= test_mkstemp();
ret &= test_pread();
ret &= test_pwrite();
ret &= test_getpass();
ret &= test_inet_ntoa();
ret &= test_strtoll();
ret &= test_strtoull();
ret &= test_va_copy();
ret &= test_FUNCTION();
ret &= test_MIN();
ret &= test_MAX();
ret &= test_socketpair();
ret &= test_strptime();
ret &= test_getifaddrs();
ret &= test_utime();
ret &= test_utimes();
ret &= test_memmem();
return ret;
}
int
main(void)
{
char buffer[3];
char *result = NULL;
plan(7);
result = test_strndup("foo", 8);
is_string("foo", result, "strndup longer than string");
free(result);
result = test_strndup("foo", 2);
is_string("fo", result, "strndup shorter than string");
free(result);
result = test_strndup("foo", 3);
is_string("foo", result, "strndup same size as string");
free(result);
result = test_strndup("foo", 0);
is_string("", result, "strndup of size 0");
free(result);
memcpy(buffer, "foo", 3);
result = test_strndup(buffer, 3);
is_string("foo", result, "strndup of non-nul-terminated string");
free(result);
errno = 0;
result = test_strndup(NULL, 0);
is_string(NULL, result, "strndup of NULL");
is_int(errno, EINVAL, "...and returns EINVAL");
return 0;
}
/*
* Take the amount of memory to allocate in bytes as a command-line argument
* and call test_malloc with that amount of memory.
*/
int
main(int argc, char *argv[])
{
size_t size, max;
size_t limit = 0;
int willfail = 0;
unsigned char code;
if (argc < 3)
die("Usage error. Type, size, and limit must be given.");
errno = 0;
size = strtol(argv[2], 0, 10);
if (size == 0 && errno != 0)
sysdie("Invalid size");
errno = 0;
limit = strtol(argv[3], 0, 10);
if (limit == 0 && errno != 0)
sysdie("Invalid limit");
/* If the code is capitalized, install our customized error handler. */
code = argv[1][0];
if (isupper(code)) {
xmalloc_error_handler = test_handler;
code = tolower(code);
}
/*
* Decide if the allocation should fail. If it should, set willfail to 2,
* so that if it unexpectedly succeeds, we exit with a status indicating
* that the test should be skipped.
*/
max = size;
if (code == 's' || code == 'n' || code == 'a' || code == 'v') {
max += size;
if (limit > 0)
limit += size;
}
if (limit > 0 && max > limit)
willfail = 2;
/*
* If a memory limit was given and we can set memory limits, set it.
* Otherwise, exit 2, signalling to the driver that the test should be
* skipped. We do this here rather than in the driver due to some
* pathological problems with Linux (setting ulimit in the shell caused
* the shell to die).
*/
if (limit > 0) {
#if HAVE_SETRLIMIT && defined(RLIMIT_AS)
struct rlimit rl;
void *tmp;
size_t test_size;
rl.rlim_cur = limit;
rl.rlim_max = limit;
if (setrlimit(RLIMIT_AS, &rl) < 0) {
syswarn("Can't set data limit to %lu", (unsigned long) limit);
exit(2);
}
if (size < limit || code == 'r') {
test_size = code == 'r' ? 10 : size;
if (test_size == 0)
test_size = 1;
tmp = malloc(test_size);
if (tmp == NULL) {
syswarn("Can't allocate initial memory of %lu (limit %lu)",
(unsigned long) test_size, (unsigned long) limit);
exit(2);
}
free(tmp);
}
#else
warn("Data limits aren't supported.");
exit(2);
#endif
}
switch (code) {
case 'c': exit(test_calloc(size) ? willfail : 1);
case 'm': exit(test_malloc(size) ? willfail : 1);
case 'r': exit(test_realloc(size) ? willfail : 1);
case 's': exit(test_strdup(size) ? willfail : 1);
case 'n': exit(test_strndup(size) ? willfail : 1);
case 'a': exit(test_asprintf(size) ? willfail : 1);
case 'v': exit(test_vasprintf(size) ? willfail : 1);
default:
die("Unknown mode %c", argv[1][0]);
break;
}
exit(1);
}