Compile in pedantic mode and fail compilation on warnings. Also cleanup all existing warnings.

4 files changed, 12 insertions, 20 deletions

diff --git a/test/builtin/xor_codes/test_xor_hd_code.c b/test/builtin/xor_codes/test_xor_hd_code.c
index f6d9db2..497b052 100644
--- a/test/builtin/xor_codes/test_xor_hd_code.c
+++ b/test/builtin/xor_codes/test_xor_hd_code.c
@@ -29,7 +29,7 @@
 #include <xor_code.h>
 #include "test_xor_hd_code.h"
 
-void fill_buffer(unsigned char *buf, int size, int seed)
+void fill_buffer(char *buf, int size, int seed)
 {
   int i;
 
@@ -79,7 +79,7 @@ int test_hd_code(xor_code_t *code_desc, int num_failure_combs, int failure_combs
   parity = (char**)malloc(code_desc->m * sizeof(char*));
   fragments_needed = (int*)malloc(code_desc->k*code_desc->m*sizeof(int));
   if (!fragments_needed) {
-      fprintf(stderr, "Could not allocate memory for fragments %d\n", i);
+      fprintf(stderr, "Could not allocate memory for fragments\n");
       exit(2);
   }
 
@@ -178,15 +178,15 @@ int test_hd_code(xor_code_t *code_desc, int num_failure_combs, int failure_combs
 
     code_desc->decode(code_desc, data, parity, missing_idxs, blocksize, 1);
   
-    if (missing_idxs[0] > -1 && missing_idxs[0] < code_desc->k && check_buffer(data[missing_idx_0], blocksize, missing_idx_0) < 0) {
+    if (missing_idxs[0] > -1 && missing_idxs[0] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_0], blocksize, missing_idx_0) < 0) {
       fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[0], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
       exit(2);
     }
-    if (missing_idxs[1] > -1 && missing_idxs[1] < code_desc->k && check_buffer(data[missing_idx_1], blocksize, missing_idx_1) < 0) {
+    if (missing_idxs[1] > -1 && missing_idxs[1] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_1], blocksize, missing_idx_1) < 0) {
       fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[1], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
       exit(2);
     }
-    if (missing_idxs[2] > -1 && missing_idxs[2] < code_desc->k && check_buffer(data[missing_idx_2], blocksize, missing_idx_2) < 0) {
+    if (missing_idxs[2] > -1 && missing_idxs[2] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_2], blocksize, missing_idx_2) < 0) {
       fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[2], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
       exit(2);
     }
diff --git a/test/libec_slap.c b/test/libec_slap.c
index 3c5426c..bf1ec21 100644
--- a/test/libec_slap.c
+++ b/test/libec_slap.c
@@ -67,7 +67,7 @@ void print_mask(unsigned long mask)
     fprintf(stderr,"\n");
 }
 
-void missing_mask_to_array(unsigned long mask, unsigned int *missing)
+void missing_mask_to_array(long mask, int *missing)
 {
     unsigned int i = 0;
     unsigned long pos = 1;
@@ -100,7 +100,6 @@ static int create_frags_array_set(struct frag_array_set *set,
     unsigned int num_frags = 0;
     unsigned long i = 0;
     fragment_header_t *header = NULL;
-    char **ptr = NULL;
     size_t size = (num_data_frags + num_parity_frags) * sizeof(char *);
     char **array = malloc(size);
 
@@ -142,9 +141,9 @@ out:
     return rc;
 }
 
-static void fill_buffer(unsigned char *buf, size_t size, int seed)
+static void fill_buffer(char *buf, size_t size, int seed)
 {
-    size_t i;
+    int i;
     buf[0] = seed;
 
     for (i=1; i < size; i++) {
@@ -169,13 +168,10 @@ static int test_hd_code(struct ec_args *args,
     char **encoded_parity = NULL;
     uint64_t encoded_fragment_len = 0;
     int rc = 0;
-    int num_fragments = args->k + args->m;
-    char **available_frags = NULL;
     char *out_data = NULL;
     uint64_t out_data_len = 0;
     unsigned long mask = 0;
     int desc = -1;
-    unsigned int num_available_frags = 0;
     struct frag_array_set frags; //MOVE ME
 
     srand(time(NULL));
@@ -186,17 +182,17 @@ static int test_hd_code(struct ec_args *args,
 
     fragments_needed = (int*)malloc(args->k*args->m*sizeof(int));
     if (!fragments_needed) {
-        fprintf(stderr, "Could not allocate memory for fragments %d\n", i);
+        fprintf(stderr, "Could not allocate memory for fragments\n");
         exit(2);
     }
     memset(fragments_needed, 0,  args->k*args->m*sizeof(int));
 
     err = posix_memalign((void **) &data, 16, blocksize * args->k);
     if (err != 0 || !data) {
-        fprintf(stderr, "Could not allocate memory for data %d\n", i);
+        fprintf(stderr, "Could not allocate memory for data\n");
         exit(1);
     }
-    fill_buffer(data, blocksize * args->k, i);
+    fill_buffer(data, blocksize * args->k, 0);
 
     parity = (char**)malloc(args->m * sizeof(char*));
     for (i=0; i < args->m; i++) {
diff --git a/test/liberasurecode_test.c b/test/liberasurecode_test.c
index ecb7006..13e5925 100644
--- a/test/liberasurecode_test.c
+++ b/test/liberasurecode_test.c
@@ -406,7 +406,6 @@ static void encode_decode_test_impl(const char *backend,
     char *orig_data = NULL;
     char **encoded_data = NULL, **encoded_parity = NULL;
     uint64_t encoded_fragment_len = 0;
-    int num_fragments = args-> k + args->m;
     uint64_t decoded_data_len = 0;
     char *decoded_data = NULL;
     size_t frag_header_size =  sizeof(fragment_header_t);
@@ -438,7 +437,7 @@ static void encode_decode_test_impl(const char *backend,
         assert(metadata.idx == i);
         assert(metadata.size == encoded_fragment_len - frag_header_size);
         assert(metadata.orig_data_size == orig_data_size);
-        unsigned char *data_ptr = frag + frag_header_size;
+        char *data_ptr = frag + frag_header_size;
         int cmp_size = remaining >= metadata.size ? metadata.size : remaining;
         assert(memcmp(data_ptr, orig_data_ptr, cmp_size) == 0); 
         remaining -= cmp_size;
@@ -480,8 +479,6 @@ static void reconstruct_test_impl(const char *backend,
     char **encoded_data = NULL, **encoded_parity = NULL;
     uint64_t encoded_fragment_len = 0;
     int num_fragments = args-> k + args->m;
-    uint64_t decoded_data_len = 0;
-    char *decoded_data = NULL;
     char **avail_frags = NULL;
     int num_avail_frags = 0;
     int i = 0;
diff --git a/test/utils/chksum/test_alg_sig.c b/test/utils/chksum/test_alg_sig.c
index a0ddf4b..5314548 100644
--- a/test/utils/chksum/test_alg_sig.c
+++ b/test/utils/chksum/test_alg_sig.c
@@ -75,7 +75,6 @@ int check_parity_of_sigs(char **sigs, int num_data, int size)
     ret = 1;
   }
 
-out:
   free(parity_sig);
 
   return ret;