lib/util/tests: avoid some compiler warnings
authorStefan Metzmacher <metze@samba.org>
Thu, 27 Feb 2014 08:35:15 +0000 (09:35 +0100)
committerStefan Metzmacher <metze@samba.org>
Wed, 12 Mar 2014 22:38:17 +0000 (23:38 +0100)
Signed-off-by: Stefan Metzmacher <metze@samba.org>
lib/util/charset/tests/iconv.c
lib/util/tests/asn1_tests.c
lib/util/tests/strlist.c

index 670454101619ef1e13a39aa457d51312e5c11a34..e46295aa33e656531fa0714c2eaade29748c5344 100644 (file)
@@ -101,8 +101,10 @@ static unsigned int get_codepoint(char *buf, size_t size, const char *charset)
        memset(out, 0, sizeof(out));
 
        ret = iconv(cd, &buf, &size_in, &ptr_out, &size_out);
-
        iconv_close(cd);
+       if (ret == (size_t) -1) {
+               return (unsigned int)-1;
+       }
 
        return out[0] | (out[1]<<8) | (out[2]<<16) | (out[3]<<24);
 }
@@ -131,7 +133,8 @@ static bool test_buffer(struct torture_context *test,
 {
        uint8_t buf1[1000], buf2[1000], buf3[1000];
        size_t outsize1, outsize2, outsize3;
-       char *ptr_in;
+       const char *ptr_in1;
+       char *ptr_in2;
        char *ptr_out;
        size_t size_in1, size_in2, size_in3;
        size_t ret1, ret2, ret3, len1, len2;
@@ -173,25 +176,25 @@ static bool test_buffer(struct torture_context *test,
        }
 
        /* internal convert to charset - placing result in buf1 */
-       ptr_in = (char *)inbuf;
+       ptr_in1 = (const char *)inbuf;
        ptr_out = (char *)buf1;
        size_in1 = size;
        outsize1 = sizeof(buf1);
 
        memset(ptr_out, 0, outsize1);
        errno = 0;
-       ret1 = smb_iconv(cd2, (const char **) &ptr_in, &size_in1, &ptr_out, &outsize1);
+       ret1 = smb_iconv(cd2, &ptr_in1, &size_in1, &ptr_out, &outsize1);
        errno1 = errno;
 
        /* system convert to charset - placing result in buf2 */
-       ptr_in = (char *)inbuf;
+       ptr_in2 = (char *)inbuf;
        ptr_out = (char *)buf2;
        size_in2 = size;
        outsize2 = sizeof(buf2);
        
        memset(ptr_out, 0, outsize2);
        errno = 0;
-       ret2 = iconv(cd, &ptr_in, &size_in2, &ptr_out, &outsize2);
+       ret2 = iconv(cd, &ptr_in2, &size_in2, &ptr_out, &outsize2);
        errno2 = errno;
 
        len1 = sizeof(buf1) - outsize1;
@@ -246,13 +249,13 @@ static bool test_buffer(struct torture_context *test,
 
        /* convert back to UTF-16, putting result in buf3 */
        size = size - size_in1;
-       ptr_in = (char *)buf1;
+       ptr_in1 = (const char *)buf1;
        ptr_out = (char *)buf3;
        size_in3 = len1;
        outsize3 = sizeof(buf3);
 
        memset(ptr_out, 0, outsize3);
-       ret3 = smb_iconv(cd3, (const char **) &ptr_in, &size_in3, &ptr_out, &outsize3);
+       ret3 = smb_iconv(cd3, &ptr_in1, &size_in3, &ptr_out, &outsize3);
 
        /* we only internally support the first 1M codepoints */
        if (outsize3 != sizeof(buf3) - size &&
index 3ee64c3f7a88336e292662150d8fe94bd5c03920..3070d712c2cea65707c515f937b3aa3c96ff60cc 100644 (file)
@@ -110,47 +110,47 @@ static const struct {
        int value;
 } integer_tests[] = {
         {
-               .blob = {"\x02\x01\x00", 3},
+               .blob = { discard_const_p(uint8_t, "\x02\x01\x00"), 3},
                .value = 0
        },
        {
-               .blob = {"\x02\x01\x7f", 3},
+               .blob = { discard_const_p(uint8_t, "\x02\x01\x7f"), 3},
                .value = 127
        },
        {
-               .blob = {"\x02\x02\x00\x80", 4},
+               .blob = { discard_const_p(uint8_t, "\x02\x02\x00\x80"), 4},
                .value = 128
        },
        {
-               .blob = {"\x02\x02\x01\x00", 4},
+               .blob = { discard_const_p(uint8_t, "\x02\x02\x01\x00"), 4},
                .value = 256
        },
        {
-               .blob = {"\x02\x01\x80", 3},
+               .blob = { discard_const_p(uint8_t, "\x02\x01\x80"), 3},
                .value = -128
        },
        {
-               .blob = {"\x02\x02\xff\x7f", 4},
+               .blob = { discard_const_p(uint8_t, "\x02\x02\xff\x7f"), 4},
                .value = -129
        },
        {
-               .blob = {"\x02\x01\xff", 3},
+               .blob = { discard_const_p(uint8_t, "\x02\x01\xff"), 3},
                .value = -1
        },
        {
-               .blob = {"\x02\x02\xff\x01", 4},
+               .blob = { discard_const_p(uint8_t, "\x02\x02\xff\x01"), 4},
                .value = -255
        },
        {
-               .blob = {"\x02\x02\x00\xff", 4},
+               .blob = { discard_const_p(uint8_t, "\x02\x02\x00\xff"), 4},
                .value = 255
        },
        {
-               .blob = {"\x02\x04\x80\x00\x00\x00", 6},
+               .blob = { discard_const_p(uint8_t, "\x02\x04\x80\x00\x00\x00"), 6},
                .value = 0x80000000
        },
        {
-               .blob = {"\x02\x04\x7f\xff\xff\xff", 6},
+               .blob = { discard_const_p(uint8_t, "\x02\x04\x7f\xff\xff\xff"), 6},
                .value = 0x7fffffff
        }
 };
index 21b7b1dd1379eb93950bdc56c7929363913f35f5..5247ae5441f002e50cc3ca2d33493dd68967156d 100644 (file)
@@ -110,7 +110,8 @@ static bool test_lists_shell(struct torture_context *tctx, const void *data)
        ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->separators);
        
        torture_assert(tctx, ret1, "str_list_make_shell() must not return NULL");
-       tmp = str_list_join_shell(mem_ctx, (const char **) ret1, element->separators ? *element->separators : ' ');
+       tmp = str_list_join_shell(mem_ctx, discard_const_p(const char *, ret1),
+                                 element->separators ? *element->separators : ' ');
        ret2 = str_list_make_shell(mem_ctx, tmp, element->separators);
 
        if ((ret1 == NULL || ret2 == NULL) && ret2 != ret1) {
@@ -160,18 +161,22 @@ static bool test_list_copy(struct torture_context *tctx)
        const char *list[] = { "foo", "bar", NULL };
        const char *empty_list[] = { NULL };
        const char **null_list = NULL;
+       char **l;
 
-       result = (const char **)str_list_copy(tctx, list);
+       l = str_list_copy(tctx, list);
+       result = discard_const_p(const char *, l);
        torture_assert_int_equal(tctx, str_list_length(result), 2, "list length");
        torture_assert_str_equal(tctx, result[0], "foo", "element 0");
        torture_assert_str_equal(tctx, result[1], "bar", "element 1");
        torture_assert_str_equal(tctx, result[2], NULL, "element 2");
 
-       result = (const char **)str_list_copy(tctx, empty_list);
+       l = str_list_copy(tctx, empty_list);
+       result = discard_const_p(const char *, l);
        torture_assert_int_equal(tctx, str_list_length(result), 0, "list length");
        torture_assert_str_equal(tctx, result[0], NULL, "element 0");
 
-       result = (const char **)str_list_copy(tctx, null_list);
+       l = str_list_copy(tctx, null_list);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result == NULL, "result NULL");
        
        return true;
@@ -261,9 +266,12 @@ static bool test_list_add(struct torture_context *tctx)
                "element_3",
                NULL
        };
-       result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
+       char **l;
+
+       l = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result, "str_list_make() must not return NULL");
-       result2 = str_list_add((const char **) result, "element_3");
+       result2 = str_list_add(result, "element_3");
        torture_assert(tctx, result2, "str_list_add() must not return NULL");
        torture_assert(tctx, str_list_equal(result2, list), 
                       "str_list_add() failed");
@@ -281,7 +289,10 @@ static bool test_list_add_const(struct torture_context *tctx)
                "element_3",
                NULL
        };
-       result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
+       char **l;
+
+       l = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result, "str_list_make() must not return NULL");
        result2 = str_list_add_const(result, "element_3");
        torture_assert(tctx, result2, "str_list_add_const() must not return NULL");
@@ -300,7 +311,10 @@ static bool test_list_remove(struct torture_context *tctx)
                "element_3",
                NULL
        };
-       result = (const char **) str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
+       char **l;
+
+       l = str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result, "str_list_make() must not return NULL");
        str_list_remove(result, "element_2");
        torture_assert(tctx, str_list_equal(result, list), 
@@ -357,7 +371,10 @@ static bool test_list_unique(struct torture_context *tctx)
                "element_2",
                NULL
        };
-       result = (const char **) str_list_copy(tctx, list_dup);
+       char **l;
+
+       l = str_list_copy(tctx, list_dup);
+       result = discard_const_p(const char *, l);
        /* We must copy the list, as str_list_unique does a talloc_realloc() on it's parameter */
        result = str_list_unique(result);
        torture_assert(tctx, result, "str_list_unique() must not return NULL");
@@ -373,8 +390,11 @@ static bool test_list_unique_2(struct torture_context *tctx)
        int i;
        int count, num_dups;
        const char **result;
-       const char **list = (const char **)str_list_make_empty(tctx);
-       const char **list_dup = (const char **)str_list_make_empty(tctx);
+       char **l1 = str_list_make_empty(tctx);
+       char **l2 = str_list_make_empty(tctx);
+       const char **list = discard_const_p(const char *, l1);
+       const char **list_dup = discard_const_p(const char *, l2);
+       char **l;
 
        count = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
        num_dups = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
@@ -388,7 +408,8 @@ static bool test_list_unique_2(struct torture_context *tctx)
                list_dup = str_list_append(list_dup, list);
        }
 
-       result = (const char **)str_list_copy(tctx, list_dup);
+       l = str_list_copy(tctx, list_dup);
+       result = discard_const_p(const char *, l);
        /* We must copy the list, as str_list_unique does a talloc_realloc() on it's parameter */
        result = str_list_unique(result);
        torture_assert(tctx, result, "str_list_unique() must not return NULL");
@@ -423,7 +444,9 @@ static bool test_list_append(struct torture_context *tctx)
                "element_5",
                NULL
        };
-       result = (const char **) str_list_copy(tctx, list);
+       char **l;
+       l = str_list_copy(tctx, list);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result, "str_list_copy() must not return NULL");
        result = str_list_append(result, list2);
        torture_assert(tctx, result, "str_list_append() must not return NULL");
@@ -457,7 +480,9 @@ static bool test_list_append_const(struct torture_context *tctx)
                "element_5",
                NULL
        };
-       result = (const char **) str_list_copy(tctx, list);
+       char **l;
+       l = str_list_copy(tctx, list);
+       result = discard_const_p(const char *, l);
        torture_assert(tctx, result, "str_list_copy() must not return NULL");
        result = str_list_append_const(result, list2);
        torture_assert(tctx, result, "str_list_append_const() must not return NULL");