[SSSD] [PATCH] TEST: Fix warning: cast from pointer to integer of different size

Lukas Slebodnik lslebodn at redhat.com
Thu Nov 12 09:01:47 UTC 2015


ehlo,

you can see warnings on 32 bit machine and cmocka tests.

So the simplest reproducer is to use mock
mock --root fedora-21-i386 --resultdir . --rebuild ./sssd-1.13.90-0.fc23.src.rpm

I plan to send patch for cmocka. Therefore there is #ifndef will_return_ptr.
I would like to avoid prefixed version with sss_ because
it might be useful for other cmocka user as well.

LS
-------------- next part --------------
>From 2ca85a16de0bee09aa59081f148f072cc0aaf606 Mon Sep 17 00:00:00 2001
From: Lukas Slebodnik <lslebodn at redhat.com>
Date: Thu, 12 Nov 2015 09:22:59 +0100
Subject: [PATCH] TEST: Fix warning: cast from pointer to integer of different
 size

Warnings are caused by different size of pointer and
LargestIntegralType on 32 bit platforms.

e.g.
src/tests/cmocka/common_mock_resp_dp.c:101:88:
    warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
     will_return(sss_parse_inp_recv, domname);
                                     ^
---
 src/tests/cmocka/common_mock.h          |  5 +++++
 src/tests/cmocka/common_mock_resp_dp.c  | 10 +++++-----
 src/tests/cmocka/sss_nss_idmap-tests.c  |  4 ++--
 src/tests/cmocka/test_be_ptask.c        |  4 ++--
 src/tests/cmocka/test_dyndns.c          |  4 ++--
 src/tests/cmocka/test_fo_srv.c          |  4 ++--
 src/tests/cmocka/test_krb5_wait_queue.c |  2 +-
 src/tests/cmocka/test_nested_groups.c   | 32 +++++++++++++++----------------
 src/tests/cmocka/test_nss_srv.c         | 34 ++++++++++++++++-----------------
 src/tests/cmocka/test_pam_srv.c         |  6 +++---
 src/tests/cmocka/test_resolv_fake.c     |  2 +-
 src/tests/cmocka/test_sdap.c            |  3 ++-
 src/tests/cmocka/test_sss_sifp.c        | 28 +++++++++++++++------------
 13 files changed, 74 insertions(+), 64 deletions(-)

diff --git a/src/tests/cmocka/common_mock.h b/src/tests/cmocka/common_mock.h
index f305e6ffc45c61db92494c8b50ea11fbc2b10634..0b2baa1e501d1931a0f9f9acf8c7cfbf0de190ed 100644
--- a/src/tests/cmocka/common_mock.h
+++ b/src/tests/cmocka/common_mock.h
@@ -48,6 +48,11 @@
 
 #define sss_will_return_always(fn, value) will_return_count(fn, (value), -1)
 
+#ifndef will_return_ptr
+#define will_return_ptr(function, ptr) \
+    will_return(function, cast_ptr_to_largest_integral_type(ptr))
+#endif
+
 enum sss_test_wrapper_call {
     WRAP_CALL_WRAPPER,
     WRAP_CALL_REAL
diff --git a/src/tests/cmocka/common_mock_resp_dp.c b/src/tests/cmocka/common_mock_resp_dp.c
index f62606eb8a33b6417bbd32a7dccdbeaabd05818f..6d444bbdb93841672105c4e68277d37656d79053 100644
--- a/src/tests/cmocka/common_mock_resp_dp.c
+++ b/src/tests/cmocka/common_mock_resp_dp.c
@@ -66,11 +66,11 @@ void mock_account_recv(uint16_t dp_err, uint32_t dp_ret, char *msg,
 {
     will_return(sss_dp_get_account_recv, dp_err);
     will_return(sss_dp_get_account_recv, dp_ret);
-    will_return(sss_dp_get_account_recv, msg);
+    will_return_ptr(sss_dp_get_account_recv, msg);
 
-    will_return(sss_dp_get_account_recv, acct_cb);
+    will_return_ptr(sss_dp_get_account_recv, acct_cb);
     if (acct_cb) {
-        will_return(sss_dp_get_account_recv, pvt);
+        will_return_ptr(sss_dp_get_account_recv, pvt);
     }
 }
 
@@ -97,8 +97,8 @@ errno_t sss_parse_inp_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 
 void mock_parse_inp(const char *name, const char *domname, errno_t ret)
 {
-    will_return(sss_parse_inp_recv, name);
-    will_return(sss_parse_inp_recv, domname);
+    will_return_ptr(sss_parse_inp_recv, name);
+    will_return_ptr(sss_parse_inp_recv, domname);
     will_return(sss_parse_inp_recv, ret);
 }
 
diff --git a/src/tests/cmocka/sss_nss_idmap-tests.c b/src/tests/cmocka/sss_nss_idmap-tests.c
index 8807eca619d7b07d919168e5629042cf38f654ac..60c235a0588e1128784e3d52e4382d03c084de93 100644
--- a/src/tests/cmocka/sss_nss_idmap-tests.c
+++ b/src/tests/cmocka/sss_nss_idmap-tests.c
@@ -114,7 +114,7 @@ void test_getsidbyname(void **state)
     sid = NULL;
 
     for (c = 0; d[c].d.repbuf != NULL; c++) {
-        will_return(sss_nss_make_request, &d[0].d);
+        will_return_ptr(sss_nss_make_request, &d[0].d);
 
         ret = sss_nss_getsidbyname("test", &sid, &type);
         assert_int_equal(ret, d[0].ret);
@@ -134,7 +134,7 @@ void test_getorigbyname(void **state)
     enum sss_id_type type;
     struct sss_nss_make_request_test_data d = {buf_orig1, sizeof(buf_orig1), 0, NSS_STATUS_SUCCESS};
 
-    will_return(sss_nss_make_request, &d);
+    will_return_ptr(sss_nss_make_request, &d);
     ret = sss_nss_getorigbyname("test", &kv_list, &type);
     assert_int_equal(ret, EOK);
     assert_int_equal(type, SSS_ID_TYPE_UID);
diff --git a/src/tests/cmocka/test_be_ptask.c b/src/tests/cmocka/test_be_ptask.c
index a0daaf967a6f1ea991ff30445488ffadff51f821..07fb0c31865a823c258f4c881f5f63595bd46dcb 100644
--- a/src/tests/cmocka/test_be_ptask.c
+++ b/src/tests/cmocka/test_be_ptask.c
@@ -546,8 +546,8 @@ void test_be_ptask_offline_disable(void **state)
 
     mark_offline(test_ctx);
 
-    will_return(be_add_online_cb, test_ctx);
-    will_return(be_add_offline_cb, test_ctx);
+    will_return_ptr(be_add_online_cb, test_ctx);
+    will_return_ptr(be_add_offline_cb, test_ctx);
 
     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,
                           BE_PTASK_OFFLINE_DISABLE, 0, test_be_ptask_send,
diff --git a/src/tests/cmocka/test_dyndns.c b/src/tests/cmocka/test_dyndns.c
index 43df0e1b58793e2efe55ea1317fc1f7ca8cc579f..687e545536f5e4b7df987e46a77b98d213b7359d 100644
--- a/src/tests/cmocka/test_dyndns.c
+++ b/src/tests/cmocka/test_dyndns.c
@@ -192,9 +192,9 @@ static void dyndns_test_done(struct tevent_req *req)
 void will_return_getifaddrs(const char *ifname, const char *straddr,
                             int af_family)
 {
-    will_return(__wrap_getifaddrs, ifname);
+    will_return_ptr(__wrap_getifaddrs, ifname);
     if (ifname) {
-        will_return(__wrap_getifaddrs, straddr);
+        will_return_ptr(__wrap_getifaddrs, straddr);
     }
     if (straddr) {
         will_return(__wrap_getifaddrs, af_family);
diff --git a/src/tests/cmocka/test_fo_srv.c b/src/tests/cmocka/test_fo_srv.c
index 67f86fb17753bf90b88d007a6a1b309df830c152..a606a18e2889dfaaaa2c53388a50507f8a12f57e 100644
--- a/src/tests/cmocka/test_fo_srv.c
+++ b/src/tests/cmocka/test_fo_srv.c
@@ -294,9 +294,9 @@ static void mock_srv_results(struct ares_srv_reply *reply_list,
                              uint32_t ttl,
                              char *dns_domain)
 {
-    will_return(resolv_discover_srv_recv, reply_list);
+    will_return_ptr(resolv_discover_srv_recv, reply_list);
     will_return(resolv_discover_srv_recv, ttl);
-    will_return(resolv_discover_srv_recv, dns_domain);
+    will_return_ptr(resolv_discover_srv_recv, dns_domain);
 }
 
 static void check_server(struct test_fo_ctx *ctx,
diff --git a/src/tests/cmocka/test_krb5_wait_queue.c b/src/tests/cmocka/test_krb5_wait_queue.c
index 4add979156b88440959abb2a45f40d2abb2ca14b..9257e49c590e99ea6ea8e4fe5f2c9884e3a6f2a2 100644
--- a/src/tests/cmocka/test_krb5_wait_queue.c
+++ b/src/tests/cmocka/test_krb5_wait_queue.c
@@ -168,7 +168,7 @@ static void test_krb5_wait_mock(struct test_krb5_wait_queue *test_ctx,
 {
     test_ctx->pd->user = discard_const(username);
 
-    will_return(krb5_auth_send, username);
+    will_return_ptr(krb5_auth_send, username);
     will_return(krb5_auth_send, us_delay);
     will_return(krb5_auth_send, ret);
     will_return(krb5_auth_send, pam_status);
diff --git a/src/tests/cmocka/test_nested_groups.c b/src/tests/cmocka/test_nested_groups.c
index dc29768c5660d5815d5fab56ee70cc8c9caab330..4a8594019dfcdb769f86b4390cf9b63ccf4b18e8 100644
--- a/src/tests/cmocka/test_nested_groups.c
+++ b/src/tests/cmocka/test_nested_groups.c
@@ -183,13 +183,13 @@ static void nested_groups_test_one_group_unique_members(void **state)
     user1_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2001, "user1");
     assert_non_null(user1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user1_reply);
+    will_return_ptr(sdap_get_generic_recv, user1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     user2_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2002, "user2");
     assert_non_null(user2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user2_reply);
+    will_return_ptr(sdap_get_generic_recv, user2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     sss_will_return_always(sdap_has_deref_support, false);
@@ -243,13 +243,13 @@ static void nested_groups_test_one_group_dup_users(void **state)
     user1_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2001, "user1");
     assert_non_null(user1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user1_reply);
+    will_return_ptr(sdap_get_generic_recv, user1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     user2_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2001, "user1");
     assert_non_null(user2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user2_reply);
+    will_return_ptr(sdap_get_generic_recv, user2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     sss_will_return_always(sdap_has_deref_support, false);
@@ -307,14 +307,14 @@ static void nested_groups_test_one_group_unique_group_members(void **state)
                                                   1001, "emptygroup1", NULL);
     assert_non_null(group1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group1_reply);
+    will_return_ptr(sdap_get_generic_recv, group1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     group2_reply[0] = mock_sysdb_group_rfc2307bis(test_ctx, GROUP_BASE_DN,
                                                   1002, "emptygroup2", NULL);
     assert_non_null(group2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group2_reply);
+    will_return_ptr(sdap_get_generic_recv, group2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     sss_will_return_always(sdap_has_deref_support, false);
@@ -370,14 +370,14 @@ static void nested_groups_test_one_group_dup_group_members(void **state)
                                                   1001, "emptygroup1", NULL);
     assert_non_null(group1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group1_reply);
+    will_return_ptr(sdap_get_generic_recv, group1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     group2_reply[0] = mock_sysdb_group_rfc2307bis(test_ctx, GROUP_BASE_DN,
                                                   1001, "emptygroup1", NULL);
     assert_non_null(group2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group2_reply);
+    will_return_ptr(sdap_get_generic_recv, group2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     sss_will_return_always(sdap_has_deref_support, false);
@@ -440,7 +440,7 @@ static void nested_groups_test_nested_chain(void **state)
     user1_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2001, "user1");
     assert_non_null(user1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user1_reply);
+    will_return_ptr(sdap_get_generic_recv, user1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     group1_reply[0] = mock_sysdb_group_rfc2307bis(test_ctx, GROUP_BASE_DN,
@@ -448,13 +448,13 @@ static void nested_groups_test_nested_chain(void **state)
                                                   group1_members);
     assert_non_null(group1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group1_reply);
+    will_return_ptr(sdap_get_generic_recv, group1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     user2_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2002, "user2");
     assert_non_null(user2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user2_reply);
+    will_return_ptr(sdap_get_generic_recv, user2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     group2_reply[0] = mock_sysdb_group_rfc2307bis(test_ctx, GROUP_BASE_DN,
@@ -462,13 +462,13 @@ static void nested_groups_test_nested_chain(void **state)
                                                   group2_members);
     assert_non_null(group2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group2_reply);
+    will_return_ptr(sdap_get_generic_recv, group2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     user3_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2003, "user3");
     assert_non_null(user3_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user3_reply);
+    will_return_ptr(sdap_get_generic_recv, user3_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     sss_will_return_always(sdap_has_deref_support, false);
@@ -532,7 +532,7 @@ static void nested_groups_test_nested_chain_with_error(void **state)
                                                   group1_members);
     assert_non_null(group1_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group1_reply);
+    will_return_ptr(sdap_get_generic_recv, group1_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     group2_reply[0] = mock_sysdb_group_rfc2307bis(test_ctx, GROUP_BASE_DN,
@@ -540,13 +540,13 @@ static void nested_groups_test_nested_chain_with_error(void **state)
                                                   group2_members);
     assert_non_null(group2_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, group2_reply);
+    will_return_ptr(sdap_get_generic_recv, group2_reply);
     will_return(sdap_get_generic_recv, ERR_OK);
 
     user_reply[0] = mock_sysdb_user(test_ctx, USER_BASE_DN, 2001, "user1");
     assert_non_null(user_reply[0]);
     will_return(sdap_get_generic_recv, 1);
-    will_return(sdap_get_generic_recv, user_reply);
+    will_return_ptr(sdap_get_generic_recv, user_reply);
     will_return(sdap_get_generic_recv, EIO);
 
     sss_will_return_always(sdap_has_deref_support, false);
diff --git a/src/tests/cmocka/test_nss_srv.c b/src/tests/cmocka/test_nss_srv.c
index f05b55e461d9a058a4894800b2efae3417c8dc01..ba62f5ae0cfa5acc318757ccfcf74be29dc41479 100644
--- a/src/tests/cmocka/test_nss_srv.c
+++ b/src/tests/cmocka/test_nss_srv.c
@@ -119,7 +119,7 @@ typedef int (*cmd_cb_fn_t)(uint32_t, uint8_t *, size_t );
 
 static void set_cmd_cb(cmd_cb_fn_t fn)
 {
-    will_return(__wrap_sss_cmd_done, fn);
+    will_return_ptr(__wrap_sss_cmd_done, fn);
 }
 
 void __wrap_sss_cmd_done(struct cli_ctx *cctx, void *freectx)
@@ -201,7 +201,7 @@ int __wrap_sss_ncache_check_sid(struct sss_nc_ctx *ctx,
 static void mock_input_user_or_group(const char *username)
 {
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, username);
+    will_return_ptr(__wrap_sss_packet_get_body, username);
     will_return(__wrap_sss_packet_get_body, 0);
 }
 
@@ -214,7 +214,7 @@ static void mock_input_id(TALLOC_CTX *mem_ctx, uint32_t id)
 
     SAFEALIGN_SETMEM_UINT32(body, id, NULL);
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, body);
+    will_return_ptr(__wrap_sss_packet_get_body, body);
     will_return(__wrap_sss_packet_get_body, sizeof(uint32_t));
 }
 
@@ -1657,11 +1657,11 @@ void test_nss_well_known_getnamebysid(void **state)
     errno_t ret;
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, "S-1-5-32-550");
+    will_return_ptr(__wrap_sss_packet_get_body, "S-1-5-32-550");
     will_return(__wrap_sss_packet_get_body, 0);
     will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETNAMEBYSID);
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
-    will_return(test_nss_well_known_sid_check, "Print Operators at BUILTIN");
+    will_return_ptr(test_nss_well_known_sid_check, "Print Operators at BUILTIN");
 
     set_cmd_cb(test_nss_well_known_sid_check);
     ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETNAMEBYSID,
@@ -1678,11 +1678,11 @@ void test_nss_well_known_getnamebysid_special(void **state)
     errno_t ret;
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, "S-1-2-0");
+    will_return_ptr(__wrap_sss_packet_get_body, "S-1-2-0");
     will_return(__wrap_sss_packet_get_body, 0);
     will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETNAMEBYSID);
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
-    will_return(test_nss_well_known_sid_check, "LOCAL at LOCAL AUTHORITY");
+    will_return_ptr(test_nss_well_known_sid_check, "LOCAL at LOCAL AUTHORITY");
 
     set_cmd_cb(test_nss_well_known_sid_check);
     ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETNAMEBYSID,
@@ -1699,10 +1699,10 @@ void test_nss_well_known_getnamebysid_non_existing(void **state)
     errno_t ret;
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, "S-1-5-32-123");
+    will_return_ptr(__wrap_sss_packet_get_body, "S-1-5-32-123");
     will_return(__wrap_sss_packet_get_body, 0);
     will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETNAMEBYSID);
-    will_return(test_nss_well_known_sid_check, NULL);
+    will_return_ptr(test_nss_well_known_sid_check, NULL);
 
     set_cmd_cb(test_nss_well_known_sid_check);
     ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETNAMEBYSID,
@@ -1719,10 +1719,10 @@ void test_nss_well_known_getidbysid_failure(void **state)
     errno_t ret;
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, "S-1-5-32-550");
+    will_return_ptr(__wrap_sss_packet_get_body, "S-1-5-32-550");
     will_return(__wrap_sss_packet_get_body, 0);
     will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETIDBYSID);
-    will_return(test_nss_well_known_sid_check, NULL);
+    will_return_ptr(test_nss_well_known_sid_check, NULL);
 
     set_cmd_cb(test_nss_well_known_sid_check);
     ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETIDBYSID,
@@ -1743,11 +1743,11 @@ void test_nss_well_known_getsidbyname(void **state)
 
     for (c = 0; names[c] != NULL; c++) {
         will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-        will_return(__wrap_sss_packet_get_body, names[c]);
+        will_return_ptr(__wrap_sss_packet_get_body, names[c]);
         will_return(__wrap_sss_packet_get_body, 0);
         will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETSIDBYNAME);
         will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
-        will_return(test_nss_well_known_sid_check, "S-1-5-32-569");
+        will_return_ptr(test_nss_well_known_sid_check, "S-1-5-32-569");
 
         set_cmd_cb(test_nss_well_known_sid_check);
         ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETSIDBYNAME,
@@ -1768,10 +1768,10 @@ void test_nss_well_known_getsidbyname_nonexisting(void **state)
 
     for (c = 0; names[c] != NULL; c++) {
         will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-        will_return(__wrap_sss_packet_get_body, names[c]);
+        will_return_ptr(__wrap_sss_packet_get_body, names[c]);
         will_return(__wrap_sss_packet_get_body, 0);
         will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETSIDBYNAME);
-        will_return(test_nss_well_known_sid_check, NULL);
+        will_return_ptr(test_nss_well_known_sid_check, NULL);
 
         set_cmd_cb(test_nss_well_known_sid_check);
         ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETSIDBYNAME,
@@ -1793,11 +1793,11 @@ void test_nss_well_known_getsidbyname_special(void **state)
 
     for (c = 0; names[c] != NULL; c++) {
         will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-        will_return(__wrap_sss_packet_get_body, names[c]);
+        will_return_ptr(__wrap_sss_packet_get_body, names[c]);
         will_return(__wrap_sss_packet_get_body, 0);
         will_return(__wrap_sss_packet_get_cmd, SSS_NSS_GETSIDBYNAME);
         will_return(__wrap_sss_packet_get_body, WRAP_CALL_REAL);
-        will_return(test_nss_well_known_sid_check, "S-1-3-0");
+        will_return_ptr(test_nss_well_known_sid_check, "S-1-3-0");
 
         set_cmd_cb(test_nss_well_known_sid_check);
         ret = sss_cmd_execute(nss_test_ctx->cctx, SSS_NSS_GETSIDBYNAME,
diff --git a/src/tests/cmocka/test_pam_srv.c b/src/tests/cmocka/test_pam_srv.c
index f3fbf907a02205e2da06e30f433048624e8e2103..04d33aff6087c19bdc30dbbb83172b1c8120f898 100644
--- a/src/tests/cmocka/test_pam_srv.c
+++ b/src/tests/cmocka/test_pam_srv.c
@@ -402,7 +402,7 @@ int __wrap_sss_cmd_send_empty(struct cli_ctx *cctx, TALLOC_CTX *freectx)
 
 static void set_cmd_cb(cmd_cb_fn_t fn)
 {
-    will_return(__wrap_sss_cmd_done, fn);
+    will_return_ptr(__wrap_sss_cmd_done, fn);
 }
 
 int __wrap_pam_dp_send_req(struct pam_auth_req *preq, int timeout)
@@ -477,7 +477,7 @@ static void mock_input_pam(TALLOC_CTX *mem_ctx, const char *name,
     assert_non_null(buf);
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, buf);
+    will_return_ptr(__wrap_sss_packet_get_body, buf);
     will_return(__wrap_sss_packet_get_body, buf_size);
 }
 
@@ -523,7 +523,7 @@ static void mock_input_pam_cert(TALLOC_CTX *mem_ctx, const char *name,
     assert_non_null(buf);
 
     will_return(__wrap_sss_packet_get_body, WRAP_CALL_WRAPPER);
-    will_return(__wrap_sss_packet_get_body, buf);
+    will_return_ptr(__wrap_sss_packet_get_body, buf);
     will_return(__wrap_sss_packet_get_body, buf_size);
 }
 
diff --git a/src/tests/cmocka/test_resolv_fake.c b/src/tests/cmocka/test_resolv_fake.c
index a1e9ee4cba9b17d506eeae7e6088de28c301364d..a3307dfd320a46b02491f190c9bd84aada30edb5 100644
--- a/src/tests/cmocka/test_resolv_fake.c
+++ b/src/tests/cmocka/test_resolv_fake.c
@@ -199,7 +199,7 @@ void mock_ares_query(int status, int timeouts, unsigned char *abuf, int alen)
 {
     will_return(__wrap_ares_query, status);
     will_return(__wrap_ares_query, timeouts);
-    will_return(__wrap_ares_query, abuf);
+    will_return_ptr(__wrap_ares_query, abuf);
     will_return(__wrap_ares_query, alen);
 }
 
diff --git a/src/tests/cmocka/test_sdap.c b/src/tests/cmocka/test_sdap.c
index d9f807076b56b24b5abbff8cefa3da3d9ed8369b..b8e430fea0f200987415a7878eab08e87acefef3 100644
--- a/src/tests/cmocka/test_sdap.c
+++ b/src/tests/cmocka/test_sdap.c
@@ -53,7 +53,8 @@ static struct mock_ldap_entry *mock_ldap_entry_get(void)
 
 void set_entry_parse(struct mock_ldap_entry *entry)
 {
-    will_return_always(mock_ldap_entry_get, entry);
+    will_return_always(mock_ldap_entry_get,
+                       cast_ptr_to_largest_integral_type(entry));
 }
 
 LDAPDerefRes *mock_deref_res(TALLOC_CTX *mem_ctx,
diff --git a/src/tests/cmocka/test_sss_sifp.c b/src/tests/cmocka/test_sss_sifp.c
index acf6a6ec87f4dddb0c92186e66da959e1ddd8463..40aafda01c59435b54c1002f455fb3703f703288 100644
--- a/src/tests/cmocka/test_sss_sifp.c
+++ b/src/tests/cmocka/test_sss_sifp.c
@@ -1657,7 +1657,7 @@ void test_sss_sifp_fetch_attr(void **state)
 
     /* prepare message */
     reply_variant_basic(reply, DBUS_TYPE_UINT32_AS_STRING, &in);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     /* test */
     ret = sss_sifp_fetch_attr(ctx, "/test/object", "test.com", name, &attrs);
@@ -1736,7 +1736,7 @@ void test_sss_sifp_fetch_all_attrs(void **state)
 
     bret = dbus_message_iter_close_container(&iter, &array_iter);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     ret = sss_sifp_fetch_all_attrs(ctx, "/test/object", "test.com", &attrs);
     assert_int_equal(ret, SSS_SIFP_OK);
@@ -1818,7 +1818,7 @@ void test_sss_sifp_fetch_object(void **state)
 
     bret = dbus_message_iter_close_container(&iter, &array_iter);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     ret = sss_sifp_fetch_object(ctx, path, iface, &object);
     assert_int_equal(ret, SSS_SIFP_OK);
@@ -1867,7 +1867,7 @@ void test_sss_sifp_invoke_list_zeroargs(void **state)
                                            &paths, path_in_len,
                                            DBUS_TYPE_INVALID);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     /* test */
     ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID);
@@ -1903,7 +1903,7 @@ void test_sss_sifp_invoke_list_withargs(void **state)
                                            &paths, path_in_len,
                                            DBUS_TYPE_INVALID);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     /* test */
     ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out,
@@ -1935,7 +1935,7 @@ void test_sss_sifp_invoke_find_zeroargs(void **state)
     bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in,
                                            DBUS_TYPE_INVALID);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     /* test */
     ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID);
@@ -1961,7 +1961,7 @@ void test_sss_sifp_invoke_find_withargs(void **state)
     bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in,
                                            DBUS_TYPE_INVALID);
     assert_true(bret);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, reply);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, reply);
 
     /* test */
     ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out,
@@ -2010,9 +2010,11 @@ void test_sss_sifp_list_domains(void **state)
     reply_variant_basic(msg_ldap, DBUS_TYPE_STRING_AS_STRING, &names[0]);
     reply_variant_basic(msg_ipa, DBUS_TYPE_STRING_AS_STRING, &names[1]);
 
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_paths);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_ldap);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_ipa);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block,
+                    msg_paths);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block,
+                    msg_ldap);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block, msg_ipa);
 
     /* test */
     ret = sss_sifp_list_domains(ctx, &out);
@@ -2104,8 +2106,10 @@ void test_sss_sifp_fetch_domain_by_name(void **state)
     bret = dbus_message_iter_close_container(&iter, &array_iter);
     assert_true(bret);
 
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_path);
-    will_return(__wrap_dbus_connection_send_with_reply_and_block, msg_props);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block,
+                    msg_path);
+    will_return_ptr(__wrap_dbus_connection_send_with_reply_and_block,
+                    msg_props);
 
     /* test */
     ret = sss_sifp_fetch_domain_by_name(ctx, name, &out);
-- 
2.5.0



More information about the sssd-devel mailing list