#include "test-compositor.h"
-extern int leak_check_enabled;
+extern int fd_leak_check_enabled;
TEST(empty)
{
assert(0);
}
-FAIL_TEST(sanity_malloc_direct)
-{
- void *p;
-
- assert(leak_check_enabled);
-
- p = malloc(10); /* memory leak */
- assert(p); /* assert that we got memory, also prevents
- * the malloc from getting optimized away. */
- free(NULL); /* NULL must not be counted */
- test_disable_coredumps();
-}
-
-TEST(disable_leak_checks)
-{
- volatile void *mem;
- assert(leak_check_enabled);
- /* normally this should be on the beginning of the test.
- * Here we need to be sure, that the leak checks are
- * turned on */
- DISABLE_LEAK_CHECKS;
-
- mem = malloc(16);
- assert(mem);
-}
-
-FAIL_TEST(sanity_malloc_indirect)
-{
- struct wl_array array;
-
- assert(leak_check_enabled);
-
- wl_array_init(&array);
-
- /* call into library that calls malloc */
- wl_array_add(&array, 14);
-
- /* not freeing array, must leak */
-
- test_disable_coredumps();
-}
-
-FAIL_TEST(tc_client_memory_leaks)
-{
- struct display *d = display_create();
- client_create_noarg(d, sanity_malloc_direct);
- display_run(d);
- test_disable_coredumps();
- display_destroy(d);
-}
-
-FAIL_TEST(tc_client_memory_leaks2)
-{
- struct display *d = display_create();
- client_create_noarg(d, sanity_malloc_indirect);
- display_run(d);
- test_disable_coredumps();
- display_destroy(d);
-}
-
FAIL_TEST(sanity_fd_leak)
{
int fd[2];
- assert(leak_check_enabled);
+ assert(fd_leak_check_enabled);
/* leak 2 file descriptors */
if (pipe(fd) < 0)
{
int fd[2];
- assert(leak_check_enabled);
+ assert(fd_leak_check_enabled);
/* leak 2 file descriptors */
if (pipe(fd) < 0)
int wayland_sock, int client_pipe)
{
char s[8];
- int cur_alloc, cur_fds;
+ int cur_fds;
int can_continue = 0;
/* Wait until display signals that client can continue */
snprintf(s, sizeof s, "%d", wayland_sock);
setenv("WAYLAND_SOCKET", s, 0);
- cur_alloc = get_current_alloc_num();
cur_fds = count_open_fds();
client_main(data);
if (!getenv("WAYLAND_SOCKET"))
cur_fds--;
- check_leaks(cur_alloc, cur_fds);
+ check_fd_leaks(cur_fds);
}
static struct client_info *
#include "test-runner.h"
-static int num_alloc;
-static void* (*sys_malloc)(size_t);
-static void (*sys_free)(void*);
-static void* (*sys_realloc)(void*, size_t);
-static void* (*sys_calloc)(size_t, size_t);
-
-/* when set to 1, check if tests are not leaking memory and opened files.
+/* when set to 1, check if tests are not leaking opened files.
* It is turned on by default. It can be turned off by
* WAYLAND_TEST_NO_LEAK_CHECK environment variable. */
-int leak_check_enabled;
+int fd_leak_check_enabled;
/* when this var is set to 0, every call to test_set_timeout() is
* suppressed - handy when debugging the test. Can be set by
extern const struct test __start_test_section, __stop_test_section;
-__attribute__ ((visibility("default"))) void *
-malloc(size_t size)
-{
- num_alloc++;
- return sys_malloc(size);
-}
-
-__attribute__ ((visibility("default"))) void
-free(void* mem)
-{
- if (mem != NULL)
- num_alloc--;
- sys_free(mem);
-}
-
-__attribute__ ((visibility("default"))) void *
-realloc(void* mem, size_t size)
-{
- if (mem == NULL)
- num_alloc++;
- return sys_realloc(mem, size);
-}
-
-__attribute__ ((visibility("default"))) void *
-calloc(size_t nmemb, size_t size)
-{
- if (sys_calloc == NULL)
- return NULL;
-
- num_alloc++;
-
- return sys_calloc(nmemb, size);
-}
-
static const struct test *
find_test(const char *name)
{
abort();
}
-int
-get_current_alloc_num(void)
-{
- return num_alloc;
-}
-
void
-check_leaks(int supposed_alloc, int supposed_fds)
+check_fd_leaks(int supposed_fds)
{
int num_fds;
- if (leak_check_enabled) {
- if (supposed_alloc != num_alloc) {
- fprintf(stderr, "Memory leak detected in test. "
- "Allocated %d blocks, unfreed %d\n", num_alloc,
- num_alloc - supposed_alloc);
- abort();
- }
-
+ if (fd_leak_check_enabled) {
num_fds = count_open_fds();
if (supposed_fds != num_fds) {
fprintf(stderr, "fd leak detected in test. "
abort();
}
} else {
- fprintf(stderr, "Leak checks disabled\n");
+ fprintf(stderr, "FD leak checks disabled\n");
}
}
static void
run_test(const struct test *t)
{
- int cur_alloc, cur_fds;
+ int cur_fds;
struct sigaction sa;
if (timeouts_enabled) {
assert(sigaction(SIGALRM, &sa, NULL) == 0);
}
- cur_alloc = get_current_alloc_num();
+ //cur_alloc = get_current_alloc_num();
cur_fds = count_open_fds();
t->run();
if (timeouts_enabled)
alarm(0);
- check_leaks(cur_alloc, cur_fds);
+ check_fd_leaks(cur_fds);
exit(EXIT_SUCCESS);
}
int total, pass;
siginfo_t info;
- /* Load system malloc, free, and realloc */
- sys_calloc = dlsym(RTLD_NEXT, "calloc");
- sys_realloc = dlsym(RTLD_NEXT, "realloc");
- sys_malloc = dlsym(RTLD_NEXT, "malloc");
- sys_free = dlsym(RTLD_NEXT, "free");
-
if (isatty(fileno(stderr)))
is_atty = 1;
if (is_debugger_attached()) {
- leak_check_enabled = 0;
+ fd_leak_check_enabled = 0;
timeouts_enabled = 0;
} else {
- leak_check_enabled = !getenv("WAYLAND_TEST_NO_LEAK_CHECK");
+ fd_leak_check_enabled = !getenv("WAYLAND_TEST_NO_LEAK_CHECK");
timeouts_enabled = !getenv("WAYLAND_TEST_NO_TIMEOUTS");
}