[SSSD] [PATCH] Make leak checks usable in tests that do not utilize check

Jakub Hrozek jhrozek at redhat.com
Mon Apr 15 14:39:20 UTC 2013


On Thu, Apr 11, 2013 at 05:06:21PM +0200, Lukas Slebodnik wrote:
> On (11/04/13 15:08), Lukas Slebodnik wrote:
> >On (11/04/13 09:52), Jakub Hrozek wrote:
> >>I am using the leak check to make sure the dyndns requests do not leak,
> >>but the leak checks were only usable in conjunction with check. This
> >>patch does the following:
> >>
> >>* Remove check-specific failure reporting from common_check.c
> >>* Add check-specific abstraction over memleak checks
> >>* Rename common_check.c to leak_check.c
> >
> >I tried to simulate memory leak. And it works like expected.
> >
> >Ack
> >
> >LS
> 
> After off list discussion. We find out, that Jakub squashs changes
> from resolv-tests.c to another commit.
> 
> $git grep -En 'check_leaks_(push|pop)'
> resolv-tests.c:121:    check_leaks_push(ctx);
> resolv-tests.c:154:    check_leaks_pop(ctx);
> resolv-tests.c:206:    check_leaks_push(test_ctx);
> resolv-tests.c:220:    check_leaks_pop(test_ctx);
> resolv-tests.c:275:    check_leaks_push(test_ctx);
> resolv-tests.c:289:    check_leaks_pop(test_ctx);
> resolv-tests.c:331:    check_leaks_push(test_ctx);
> resolv-tests.c:345:    check_leaks_pop(test_ctx);
> resolv-tests.c:369:    check_leaks_push(tmp_ctx);
> resolv-tests.c:420:    check_leaks_pop(tmp_ctx);
> resolv-tests.c:437:    check_leaks_push(test_ctx);
> resolv-tests.c:452:    check_leaks_pop(test_ctx);
> resolv-tests.c:467:    check_leaks_push(test_ctx);
> resolv-tests.c:476:    check_leaks_pop(test_ctx);
> resolv-tests.c:492:    check_leaks_push(test_ctx);
> resolv-tests.c:501:    check_leaks_pop(test_ctx);
> resolv-tests.c:603:    check_leaks_push(test_ctx);
> resolv-tests.c:670:    check_leaks_pop(test_ctx);
> resolv-tests.c:690:    check_leaks_push(test_ctx);
> resolv-tests.c:719:    check_leaks_pop(test_ctx);
> resolv-tests.c:740:    check_leaks_push(tmp_ctx);
> resolv-tests.c:748:    check_leaks_pop(tmp_ctx);
> 
> LS

Thanks for the review, a new patch is attached.
-------------- next part --------------
>From 1797cc82bd59b3ab7c41ed18319f40ad72ce18f0 Mon Sep 17 00:00:00 2001
From: Jakub Hrozek <jhrozek at redhat.com>
Date: Mon, 1 Apr 2013 13:22:49 +0200
Subject: [PATCH] Make leak checks usable in tests that do not utilize check

* Remove check-specific failure reporting from common_check.c
* Check-specific abstraction over memleak checks
* Rename common_check.c to leak_check.c
---
 Makefile.am                                |  4 +-
 src/tests/common.h                         |  9 ++--
 src/tests/common_check.c                   | 86 +++---------------------------
 src/tests/common_check.h                   | 36 +++++++++++++
 src/tests/crypto-tests.c                   |  8 +--
 src/tests/fail_over-tests.c                | 12 ++---
 src/tests/ipa_hbac-tests.c                 |  6 +--
 src/tests/{common_check.c => leak_check.c} | 49 ++++++++++++-----
 src/tests/pac_responder-tests.c            |  6 +--
 src/tests/refcount-tests.c                 |  8 +--
 src/tests/resolv-tests.c                   | 48 ++++++++---------
 src/tests/sss_idmap-tests.c                | 18 +++----
 src/tests/util-tests.c                     |  6 +--
 13 files changed, 144 insertions(+), 152 deletions(-)
 create mode 100644 src/tests/common_check.h
 copy src/tests/{common_check.c => leak_check.c} (69%)

diff --git a/Makefile.am b/Makefile.am
index 332669551a781263e44fd855a920d370b5898c15..09056b5d9fec1d23213132940d11c312bcbfc23d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -474,6 +474,7 @@ dist_noinst_HEADERS = \
     src/resolv/ares/ares_parse_txt_reply.h \
     src/resolv/ares/ares_data.h \
     src/tests/common.h \
+    src/tests/common_check.h \
     src/tests/cmocka/common_mock.h \
     src/tests/cmocka/common_mock_resp.h \
     src/sss_client/ssh/sss_ssh_client.h \
@@ -848,7 +849,8 @@ libsss_test_common_la_SOURCES = \
 
 if HAVE_CHECK
 libsss_test_common_la_SOURCES += \
-    src/tests/common_check.c
+    src/tests/common_check.c	 \
+    src/tests/leak_check.c
 
 sysdb_tests_DEPENDENCIES = \
     $(ldblib_LTLIBRARIES)
diff --git a/src/tests/common.h b/src/tests/common.h
index 61dcbf41fb99312f68e5f06100c3fe25049038f0..e7fc812c7803cd5a5b85bb466f781e4a8efc3012 100644
--- a/src/tests/common.h
+++ b/src/tests/common.h
@@ -33,17 +33,18 @@
 extern TALLOC_CTX *global_talloc_context;
 
 #define check_leaks(ctx, bytes) _check_leaks((ctx), (bytes), __location__)
-void _check_leaks(TALLOC_CTX *ctx,
+bool _check_leaks(TALLOC_CTX *ctx,
                   size_t bytes,
                   const char *location);
 
 void check_leaks_push(TALLOC_CTX *ctx);
 
 #define check_leaks_pop(ctx) _check_leaks_pop((ctx), __location__)
-void _check_leaks_pop(TALLOC_CTX *ctx, const char *location);
+bool _check_leaks_pop(TALLOC_CTX *ctx, const char *location);
 
-void leak_check_setup(void);
-void leak_check_teardown(void);
+bool leak_check_setup(void);
+bool leak_check_teardown(void);
+const char *check_leaks_err_msg(void);
 
 void tests_set_cwd(void);
 
diff --git a/src/tests/common_check.c b/src/tests/common_check.c
index d845923fb1792a5cddb948a4fca5048296eb51c6..94ca40ffe28543e2fee28a56ccc62e77831b2b67 100644
--- a/src/tests/common_check.c
+++ b/src/tests/common_check.c
@@ -1,7 +1,7 @@
 /*
    SSSD
 
-   Common utilities for check-based tests using talloc.
+   Memory leak/growth checks for check-based tests using talloc.
 
    Authors:
         Martin Nagy <mnagy at redhat.com>
@@ -22,88 +22,18 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <stdio.h>
 #include <check.h>
+
 #include "tests/common.h"
-#include "util/util.h"
-#include "util/dlinklist.h"
 
-TALLOC_CTX *global_talloc_context = NULL;
-
-
-struct size_snapshot {
-    struct size_snapshot *prev;
-    struct size_snapshot *next;
-
-    TALLOC_CTX *ctx;
-    size_t bytes_allocated;
-};
-
-static struct size_snapshot *snapshot_stack;
-
-void
-_check_leaks(TALLOC_CTX *ctx, size_t bytes, const char *location)
-{
-    size_t bytes_allocated;
-
-    bytes_allocated = talloc_total_size(ctx);
-    if (bytes_allocated != bytes) {
-        fprintf(stderr, "Leak report for %s:\n", location);
-        talloc_report_full(ctx, stderr);
-        fail("%s: memory leaks detected, %d bytes still allocated",
-             location, bytes_allocated - bytes);
-    }
-}
-
-void
-check_leaks_push(TALLOC_CTX *ctx)
-{
-    struct size_snapshot *snapshot;
-
-    snapshot = talloc(NULL, struct size_snapshot);
-    snapshot->ctx = ctx;
-    snapshot->bytes_allocated = talloc_total_size(ctx);
-    DLIST_ADD(snapshot_stack, snapshot);
-}
-
-void
-_check_leaks_pop(TALLOC_CTX *ctx, const char *location)
-{
-    struct size_snapshot *snapshot;
-    TALLOC_CTX *old_ctx;
-    size_t bytes_allocated;
-
-    if (snapshot_stack == NULL) {
-        fail("%s: trying to pop an empty stack");
-    }
-
-    snapshot = snapshot_stack;
-    DLIST_REMOVE(snapshot_stack, snapshot);
-
-    old_ctx = snapshot->ctx;
-    bytes_allocated = snapshot->bytes_allocated;
-
-    fail_if(old_ctx != ctx, "Bad push/pop order");
-
-    talloc_zfree(snapshot);
-    _check_leaks(old_ctx, bytes_allocated, location);
-}
-
-void
-leak_check_setup(void)
+void ck_leak_check_setup(void)
 {
-    talloc_enable_null_tracking();
-    global_talloc_context = talloc_new(NULL);
-    fail_unless(global_talloc_context != NULL, "talloc_new failed");
-    check_leaks_push(global_talloc_context);
+    fail_unless(leak_check_setup() == true,
+                "Cannot set up leaks test: %s\n", check_leaks_err_msg());
 }
 
-void
-leak_check_teardown(void)
+void ck_leak_check_teardown(void)
 {
-    check_leaks_pop(global_talloc_context);
-    if (snapshot_stack != NULL) {
-        fail("Exiting with a non-empty stack");
-    }
-    check_leaks(global_talloc_context, 0);
+    fail_unless(leak_check_teardown() == true,
+                "Cannot tear down leaks test: %s\n", check_leaks_err_msg());
 }
diff --git a/src/tests/common_check.h b/src/tests/common_check.h
new file mode 100644
index 0000000000000000000000000000000000000000..51c3c3f4989091a6d472c4635bbbb8c61ffafdb4
--- /dev/null
+++ b/src/tests/common_check.h
@@ -0,0 +1,36 @@
+/*
+   SSSD
+
+   Memory leak/growth checks for check-based tests using talloc.
+
+   Authors:
+        Martin Nagy <mnagy at redhat.com>
+
+   Copyright (C) Red Hat, Inc 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __TESTS_COMMON_CHECK_H__
+#define __TESTS_COMMON_CHECK_H__
+
+#include "tests/common.h"
+
+void ck_leak_check_setup(void);
+void ck_leak_check_teardown(void);
+
+#define ck_leaks_push(ctx) check_leaks_push(ctx)
+#define ck_leaks_pop(ctx) fail_unless(check_leaks_pop(ctx) == true, check_leaks_err_msg())
+
+#endif /* __TESTS_COMMON_CHECK_H__ */
diff --git a/src/tests/crypto-tests.c b/src/tests/crypto-tests.c
index 8932d8f5662647329bd1520fd9f40cf84df64a6e..87184594e2fb7cedc234350b56aa341d9de62713 100644
--- a/src/tests/crypto-tests.c
+++ b/src/tests/crypto-tests.c
@@ -26,7 +26,7 @@
 #include <check.h>
 
 #include "util/util.h"
-#include "tests/common.h"
+#include "tests/common_check.h"
 
 /* interfaces under test */
 #include "util/crypto/sss_crypto.h"
@@ -68,7 +68,7 @@ START_TEST(test_encrypt_decrypt)
 
     test_ctx = talloc_new(NULL);
     fail_if(test_ctx == NULL);
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
 
     for (i=0; password[i]; i++) {
         ret = sss_password_encrypt(test_ctx, password[i], strlen(password[i])+1,
@@ -84,7 +84,7 @@ START_TEST(test_encrypt_decrypt)
         talloc_free(ctpwd);
     }
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     talloc_free(test_ctx);
 }
 END_TEST
@@ -163,7 +163,7 @@ Suite *crypto_suite(void)
     Suite *s = suite_create("sss_crypto");
 
     TCase *tc = tcase_create("sss crypto tests");
-    tcase_add_checked_fixture(tc, leak_check_setup, leak_check_teardown);
+    tcase_add_checked_fixture(tc, ck_leak_check_setup, ck_leak_check_teardown);
     /* Do some testing */
 #ifdef HAVE_NSS
     tcase_add_test(tc, test_nss_init);
diff --git a/src/tests/fail_over-tests.c b/src/tests/fail_over-tests.c
index 93dda3a77aef9c7e000051dccf8b1b6e2ba83dff..c00025960f9ee593eb7f33a1bb13df056a702816 100644
--- a/src/tests/fail_over-tests.c
+++ b/src/tests/fail_over-tests.c
@@ -32,7 +32,7 @@
 #include <tevent.h>
 
 #include "resolv/async_resolv.h"
-#include "tests/common.h"
+#include "tests/common_check.h"
 #include "util/util.h"
 
 /* Interface under test */
@@ -107,13 +107,13 @@ START_TEST(test_fo_new_service)
     struct fo_service *services[10];
 
     ctx = setup_test();
-    check_leaks_push(ctx);
+    ck_leaks_push(ctx);
 
     for (i = 0; i < 10; i++) {
         char buf[16];
         sprintf(buf, "service_%d", i);
 
-        check_leaks_push(ctx);
+        ck_leaks_push(ctx);
         ret = fo_new_service(ctx->fo_ctx, buf, NULL, &services[i]);
         fail_if(ret != EOK);
     }
@@ -129,13 +129,13 @@ START_TEST(test_fo_new_service)
         fail_if(ret != EOK);
         fail_if(service != services[i]);
         talloc_free(service);
-        check_leaks_pop(ctx);
+        ck_leaks_pop(ctx);
 
         ret = fo_get_service(ctx->fo_ctx, buf, &service);
         fail_if(ret != ENOENT);
     }
 
-    check_leaks_pop(ctx);
+    ck_leaks_pop(ctx);
     talloc_free(ctx);
 }
 END_TEST
@@ -264,7 +264,7 @@ create_suite(void)
 
     TCase *tc = tcase_create("FAIL_OVER Tests");
 
-    tcase_add_checked_fixture(tc, leak_check_setup, leak_check_teardown);
+    tcase_add_checked_fixture(tc, ck_leak_check_setup, ck_leak_check_teardown);
     /* Do some testing */
     tcase_add_test(tc, test_fo_new_service);
     tcase_add_test(tc, test_fo_resolve_service);
diff --git a/src/tests/ipa_hbac-tests.c b/src/tests/ipa_hbac-tests.c
index 330e49e7c5570e02937b558701ed96df5d4e32c4..3c64fe044a2902622ae46b56687da920e8872c33 100644
--- a/src/tests/ipa_hbac-tests.c
+++ b/src/tests/ipa_hbac-tests.c
@@ -26,7 +26,7 @@
 #include <sys/stat.h>
 #include <talloc.h>
 
-#include "tests/common.h"
+#include "tests/common_check.h"
 #include "providers/ipa/ipa_hbac.h"
 
 #define HBAC_TEST_USER "testuser"
@@ -815,8 +815,8 @@ Suite *hbac_test_suite (void)
 
     TCase *tc_hbac = tcase_create("HBAC_rules");
     tcase_add_checked_fixture(tc_hbac,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
 
     tcase_add_test(tc_hbac, ipa_hbac_test_allow_all);
     tcase_add_test(tc_hbac, ipa_hbac_test_allow_user);
diff --git a/src/tests/common_check.c b/src/tests/leak_check.c
similarity index 69%
copy from src/tests/common_check.c
copy to src/tests/leak_check.c
index d845923fb1792a5cddb948a4fca5048296eb51c6..89dac357bea6929cdc4eed9c4fbab214e249730c 100644
--- a/src/tests/common_check.c
+++ b/src/tests/leak_check.c
@@ -29,7 +29,7 @@
 #include "util/dlinklist.h"
 
 TALLOC_CTX *global_talloc_context = NULL;
-
+char leak_err_msg[256];
 
 struct size_snapshot {
     struct size_snapshot *prev;
@@ -41,7 +41,17 @@ struct size_snapshot {
 
 static struct size_snapshot *snapshot_stack;
 
-void
+#define _set_leak_err_msg(fmt, ...) do {              \
+        snprintf(leak_err_msg, sizeof(leak_err_msg),  \
+                 fmt, ##__VA_ARGS__);                 \
+} while(0);
+
+const char *check_leaks_err_msg(void)
+{
+    return leak_err_msg;
+}
+
+bool
 _check_leaks(TALLOC_CTX *ctx, size_t bytes, const char *location)
 {
     size_t bytes_allocated;
@@ -50,9 +60,12 @@ _check_leaks(TALLOC_CTX *ctx, size_t bytes, const char *location)
     if (bytes_allocated != bytes) {
         fprintf(stderr, "Leak report for %s:\n", location);
         talloc_report_full(ctx, stderr);
-        fail("%s: memory leaks detected, %d bytes still allocated",
-             location, bytes_allocated - bytes);
+        _set_leak_err_msg("%s: memory leaks detected, %zd bytes still allocated",
+                          location, bytes_allocated - bytes);
+        return false;
     }
+
+    return true;
 }
 
 void
@@ -66,7 +79,7 @@ check_leaks_push(TALLOC_CTX *ctx)
     DLIST_ADD(snapshot_stack, snapshot);
 }
 
-void
+bool
 _check_leaks_pop(TALLOC_CTX *ctx, const char *location)
 {
     struct size_snapshot *snapshot;
@@ -74,7 +87,8 @@ _check_leaks_pop(TALLOC_CTX *ctx, const char *location)
     size_t bytes_allocated;
 
     if (snapshot_stack == NULL) {
-        fail("%s: trying to pop an empty stack");
+        _set_leak_err_msg("%s: trying to pop an empty stack", location);
+        return false;
     }
 
     snapshot = snapshot_stack;
@@ -83,27 +97,36 @@ _check_leaks_pop(TALLOC_CTX *ctx, const char *location)
     old_ctx = snapshot->ctx;
     bytes_allocated = snapshot->bytes_allocated;
 
-    fail_if(old_ctx != ctx, "Bad push/pop order");
+    if (old_ctx != ctx) {
+        _set_leak_err_msg("Bad push/pop order");
+        return false;
+    }
 
     talloc_zfree(snapshot);
-    _check_leaks(old_ctx, bytes_allocated, location);
+    return _check_leaks(old_ctx, bytes_allocated, location);
 }
 
-void
+bool
 leak_check_setup(void)
 {
     talloc_enable_null_tracking();
     global_talloc_context = talloc_new(NULL);
-    fail_unless(global_talloc_context != NULL, "talloc_new failed");
+    if (global_talloc_context == NULL) {
+        _set_leak_err_msg("talloc_new failed");
+        return false;
+    }
+
     check_leaks_push(global_talloc_context);
+    return true;
 }
 
-void
+bool
 leak_check_teardown(void)
 {
     check_leaks_pop(global_talloc_context);
     if (snapshot_stack != NULL) {
-        fail("Exiting with a non-empty stack");
+        _set_leak_err_msg("Exiting with a non-empty stack");
+        return false;
     }
-    check_leaks(global_talloc_context, 0);
+    return check_leaks(global_talloc_context, 0);
 }
diff --git a/src/tests/pac_responder-tests.c b/src/tests/pac_responder-tests.c
index 4b6f03f555b593f96c970eb6989a616fcb6ce1d7..ed8c9170d3cfe181fca24b8a31e30ee30d960e77 100644
--- a/src/tests/pac_responder-tests.c
+++ b/src/tests/pac_responder-tests.c
@@ -27,7 +27,7 @@
 #include <util/data_blob.h>
 #include <gen_ndr/security.h>
 
-#include "tests/common.h"
+#include "tests/common_check.h"
 #include "responder/pac/pacsrv.h"
 #include "lib/idmap/sss_idmap.h"
 
@@ -488,8 +488,8 @@ Suite *idmap_test_suite (void)
 
     TCase *tc_pac = tcase_create("PAC responder tests");
     tcase_add_checked_fixture(tc_pac,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
 
     tcase_add_checked_fixture(tc_pac,
                               pac_setup,
diff --git a/src/tests/refcount-tests.c b/src/tests/refcount-tests.c
index d93f1561f3ba753f9cf730fa8bcef003a6f106b2..9713d4783d5ea39c1550a56c048ff1fdc6852ea8 100644
--- a/src/tests/refcount-tests.c
+++ b/src/tests/refcount-tests.c
@@ -28,7 +28,7 @@
 #include <tevent.h>
 #include <popt.h>
 
-#include "tests/common.h"
+#include "tests/common_check.h"
 #include "util/util.h"
 
 /* Interface under test */
@@ -146,7 +146,7 @@ START_TEST(test_refcount_swap)
 
     tmp_ctx = talloc_new(NULL);
 
-    check_leaks_push(tmp_ctx);
+    ck_leaks_push(tmp_ctx);
 
     container1 = talloc(tmp_ctx, struct container);
     container2 = talloc(tmp_ctx, struct container);
@@ -170,7 +170,7 @@ START_TEST(test_refcount_swap)
     CHECK_FILLER(container2->foo);
     talloc_free(container2);
 
-    check_leaks_pop(tmp_ctx);
+    ck_leaks_pop(tmp_ctx);
     talloc_free(tmp_ctx);
 }
 END_TEST
@@ -182,7 +182,7 @@ Suite *create_suite(void)
     TCase *tc = tcase_create("REFCOUNT Tests");
 
     /* Do some testing */
-    tcase_add_checked_fixture(tc, leak_check_setup, leak_check_teardown);
+    tcase_add_checked_fixture(tc, ck_leak_check_setup, ck_leak_check_teardown);
     tcase_add_test(tc, test_refcount_basic);
     tcase_add_test(tc, test_refcount_swap);
 
diff --git a/src/tests/resolv-tests.c b/src/tests/resolv-tests.c
index 61308e3827ceefff662649335a6e4da032886ce0..dd212c055f6c25c9add3c49a701df19c2e802faf 100644
--- a/src/tests/resolv-tests.c
+++ b/src/tests/resolv-tests.c
@@ -33,7 +33,7 @@
 
 #include "tests/common.h"
 #include "util/util.h"
-#include "tests/common.h"
+#include "tests/common_check.h"
 
 /* Interface under test */
 #include "resolv/async_resolv.h"
@@ -118,7 +118,7 @@ START_TEST(test_copy_hostent)
     ctx = talloc_new(global_talloc_context);
     fail_if(ctx == NULL);
 
-    check_leaks_push(ctx);
+    ck_leaks_push(ctx);
 
     rhe = resolv_copy_hostent_ares(ctx, &he, AF_INET, &attl, 2);
 
@@ -151,7 +151,7 @@ START_TEST(test_copy_hostent)
 
     talloc_free(rhe);
 
-    check_leaks_pop(ctx);
+    ck_leaks_pop(ctx);
 }
 END_TEST
 
@@ -203,7 +203,7 @@ START_TEST(test_resolv_ip_addr)
         return;
     }
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
     req = resolv_gethostbyname_send(test_ctx, test_ctx->ev,
                                     test_ctx->resolv, hostname, IPV4_ONLY,
                                     default_host_dbs);
@@ -217,7 +217,7 @@ START_TEST(test_resolv_ip_addr)
         ret = test_loop(test_ctx);
     }
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     fail_unless(ret == EOK);
 
     talloc_zfree(test_ctx);
@@ -272,7 +272,7 @@ START_TEST(test_resolv_localhost)
         return;
     }
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
     req = resolv_gethostbyname_send(test_ctx, test_ctx->ev,
                                     test_ctx->resolv, hostname, IPV4_FIRST,
                                     default_host_dbs);
@@ -286,7 +286,7 @@ START_TEST(test_resolv_localhost)
         ret = test_loop(test_ctx);
     }
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     fail_unless(ret == EOK);
 
     talloc_zfree(test_ctx);
@@ -328,7 +328,7 @@ START_TEST(test_resolv_negative)
         return;
     }
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
     req = resolv_gethostbyname_send(test_ctx, test_ctx->ev,
                                     test_ctx->resolv, hostname, IPV4_FIRST,
                                     default_host_dbs);
@@ -342,7 +342,7 @@ START_TEST(test_resolv_negative)
         ret = test_loop(test_ctx);
     }
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
 
     fail_unless(ret != EOK);
     fail_unless(test_ctx->error == ARES_ENOTFOUND);
@@ -366,7 +366,7 @@ static void test_internet(struct tevent_req *req)
     test_ctx->done = true;
 
     tmp_ctx = talloc_new(test_ctx);
-    check_leaks_push(tmp_ctx);
+    ck_leaks_push(tmp_ctx);
 
     switch (test_ctx->tested_function) {
     case TESTING_HOSTNAME:
@@ -417,7 +417,7 @@ static void test_internet(struct tevent_req *req)
     } else if (srv_replies != NULL) {
         talloc_free(srv_replies);
     }
-    check_leaks_pop(tmp_ctx);
+    ck_leaks_pop(tmp_ctx);
 }
 
 START_TEST(test_resolv_internet)
@@ -434,7 +434,7 @@ START_TEST(test_resolv_internet)
     }
     test_ctx->tested_function = TESTING_HOSTNAME;
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
     req = resolv_gethostbyname_send(test_ctx, test_ctx->ev,
                                     test_ctx->resolv, hostname, IPV4_FIRST,
                                     default_host_dbs);
@@ -449,7 +449,7 @@ START_TEST(test_resolv_internet)
     }
 
     fail_unless(ret == EOK);
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     talloc_zfree(test_ctx);
 }
 END_TEST
@@ -464,7 +464,7 @@ START_TEST(test_resolv_internet_txt)
     fail_if(ret != EOK, "Could not set up test");
     test_ctx->tested_function = TESTING_TXT;
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
 
     req = resolv_gettxt_send(test_ctx, test_ctx->ev, test_ctx->resolv, txt_host);
     fail_if(req == NULL, "Function resolv_gettxt_send failed");
@@ -473,7 +473,7 @@ START_TEST(test_resolv_internet_txt)
     ret = test_loop(test_ctx);
     fail_unless(ret == EOK);
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
 
     talloc_zfree(test_ctx);
 }
@@ -489,7 +489,7 @@ START_TEST(test_resolv_internet_srv)
     fail_if(ret != EOK, "Could not set up test");
     test_ctx->tested_function = TESTING_SRV;
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
 
     req = resolv_getsrv_send(test_ctx, test_ctx->ev, test_ctx->resolv, srv_host);
     fail_if(req == NULL, "Function resolv_getsrv_send failed");
@@ -498,7 +498,7 @@ START_TEST(test_resolv_internet_srv)
     ret = test_loop(test_ctx);
     fail_unless(ret == EOK);
 
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
 
     talloc_zfree(test_ctx);
 }
@@ -600,7 +600,7 @@ START_TEST(test_resolv_sort_srv_reply)
         return;
     }
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
 
     /* prepare linked list with reversed values */
     for (i = 0; i<num_replies; i++) {
@@ -667,7 +667,7 @@ START_TEST(test_resolv_sort_srv_reply)
 
 
     /* check for leaks */
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     talloc_zfree(test_ctx);
 }
 END_TEST
@@ -687,7 +687,7 @@ START_TEST(test_resolv_free_req)
         return;
     }
 
-    check_leaks_push(test_ctx);
+    ck_leaks_push(test_ctx);
     req = resolv_gethostbyname_send(test_ctx, test_ctx->ev,
                                     test_ctx->resolv, hostname, IPV4_FIRST,
                                     default_host_dbs);
@@ -716,7 +716,7 @@ START_TEST(test_resolv_free_req)
     }
 
     ret = test_loop(test_ctx);
-    check_leaks_pop(test_ctx);
+    ck_leaks_pop(test_ctx);
     fail_unless(ret == EOK);
 
 done:
@@ -737,7 +737,7 @@ static void test_timeout(struct tevent_req *req)
     test_ctx->done = true;
 
     tmp_ctx = talloc_new(test_ctx);
-    check_leaks_push(tmp_ctx);
+    ck_leaks_push(tmp_ctx);
 
     fail_unless(test_ctx->tested_function == TESTING_HOSTNAME);
     recv_status = resolv_gethostbyname_recv(req, tmp_ctx,
@@ -745,7 +745,7 @@ static void test_timeout(struct tevent_req *req)
     talloc_zfree(req);
     fail_unless(recv_status == ETIMEDOUT);
     fail_unless(status == ARES_ETIMEOUT);
-    check_leaks_pop(tmp_ctx);
+    ck_leaks_pop(tmp_ctx);
     talloc_free(tmp_ctx);
 }
 
@@ -788,7 +788,7 @@ Suite *create_resolv_suite(void)
 
     TCase *tc_resolv = tcase_create("RESOLV Tests");
 
-    tcase_add_checked_fixture(tc_resolv, leak_check_setup, leak_check_teardown);
+    tcase_add_checked_fixture(tc_resolv, ck_leak_check_setup, ck_leak_check_teardown);
     /* Do some testing */
     tcase_add_test(tc_resolv, test_copy_hostent);
     tcase_add_test(tc_resolv, test_resolv_ip_addr);
diff --git a/src/tests/sss_idmap-tests.c b/src/tests/sss_idmap-tests.c
index e6d75372a14535ae2f64904214f48d8b2669858c..eb204137aaa402403159ed653819756d515e1ace 100644
--- a/src/tests/sss_idmap-tests.c
+++ b/src/tests/sss_idmap-tests.c
@@ -24,7 +24,7 @@
 
 #include "lib/idmap/sss_idmap.h"
 #include "lib/idmap/sss_idmap_private.h"
-#include "tests/common.h"
+#include "tests/common_check.h"
 
 #define IDMAP_RANGE_MIN 1234
 #define IDMAP_RANGE_MAX 9876
@@ -492,8 +492,8 @@ Suite *idmap_test_suite (void)
 
     TCase *tc_init = tcase_create("IDMAP init tests");
     tcase_add_checked_fixture(tc_init,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
 
     tcase_add_test(tc_init, idmap_test_init_malloc);
     tcase_add_test(tc_init, idmap_test_init_talloc);
@@ -503,8 +503,8 @@ Suite *idmap_test_suite (void)
 
     TCase *tc_dom = tcase_create("IDMAP domain tests");
     tcase_add_checked_fixture(tc_dom,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
     tcase_add_checked_fixture(tc_dom,
                               idmap_ctx_setup,
                               idmap_ctx_teardown);
@@ -515,8 +515,8 @@ Suite *idmap_test_suite (void)
 
     TCase *tc_conv = tcase_create("IDMAP SID conversion tests");
     tcase_add_checked_fixture(tc_conv,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
     tcase_add_checked_fixture(tc_conv,
                               idmap_ctx_setup,
                               idmap_ctx_teardown);
@@ -536,8 +536,8 @@ Suite *idmap_test_suite (void)
 
     TCase *tc_map = tcase_create("IDMAP mapping tests");
     tcase_add_checked_fixture(tc_map,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
     tcase_add_checked_fixture(tc_map,
                               idmap_ctx_setup,
                               idmap_ctx_teardown);
diff --git a/src/tests/util-tests.c b/src/tests/util-tests.c
index e7e04e6574f02c47f45de7bd36168c6d5d8bcd74..4b0d5009c7c65f259f66aa66eb68281098164b74 100644
--- a/src/tests/util-tests.c
+++ b/src/tests/util-tests.c
@@ -31,7 +31,7 @@
 #include "util/util.h"
 #include "util/sss_utf8.h"
 #include "util/murmurhash3.h"
-#include "tests/common.h"
+#include "tests/common_check.h"
 
 #define FILENAME_TEMPLATE "tests-atomicio-XXXXXX"
 char *filename;
@@ -815,8 +815,8 @@ Suite *util_suite(void)
     TCase *tc_util = tcase_create("util");
 
     tcase_add_checked_fixture(tc_util,
-                              leak_check_setup,
-                              leak_check_teardown);
+                              ck_leak_check_setup,
+                              ck_leak_check_teardown);
     tcase_add_test (tc_util, test_diff_string_lists);
     tcase_add_test (tc_util, test_sss_filter_sanitize);
     tcase_add_test (tc_util, test_size_t_overflow);
-- 
1.8.1.4



More information about the sssd-devel mailing list