From: bel2125 <bel2125@gmail.com>
Date: Sat, 26 Aug 2017 18:55:03 +0000 (+0200)
Subject: Adapt unit tests to C89/C90 by moving variable declarations to top of functions
X-Git-Tag: 0.12.0~4^2~24
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=5c7b77158570aa1b1851bd1b67a18973cdb6bcde;p=check

Adapt unit tests to C89/C90 by moving variable declarations to top of functions
---

diff --git a/tests/check_check_master.c b/tests/check_check_master.c
index a78a274..880fe9f 100644
--- a/tests/check_check_master.c
+++ b/tests/check_check_master.c
@@ -473,6 +473,13 @@ START_TEST(test_check_failure_msgs)
   int passed = 0;
   const char *got_msg;
   const char *expected_msg;
+  unsigned char not_equal = 0;
+  char emsg[MAXSTR];
+  const char *msg_type_str;
+  char *emsg_escaped;
+  regex_t re;
+  int reg_err;
+  char err_text[256];
   TestResult *tr;
 
   for (i = 0; i < sub_ntests; i++) {
@@ -489,8 +496,6 @@ START_TEST(test_check_failure_msgs)
     got_msg = tr_msg(tr);
     expected_msg = master_test->msg;
 
-    unsigned char not_equal = 0;
-
     switch (master_test->msg_type) {
     case CK_MSG_TEXT:
       if (strcmp(got_msg, expected_msg) != 0) {
@@ -499,10 +504,8 @@ START_TEST(test_check_failure_msgs)
       break;
 #if ENABLE_REGEX
     case CK_MSG_REGEXP: {
-      regex_t re;
-      int reg_err = regcomp(&re, expected_msg, REG_EXTENDED | REG_NOSUB);
-      if (reg_err) {
-        char err_text[256];
+      reg_err = regcomp(&re, expected_msg, REG_EXTENDED | REG_NOSUB);
+      if (reg_err) {        
         regerror(reg_err, &re, err_text, sizeof(err_text));
         ck_assert_msg(reg_err == 0,
                 "For test %d:%s:%s Expected regexp '%s', but regcomp returned error '%s'",
@@ -519,8 +522,7 @@ START_TEST(test_check_failure_msgs)
 #endif /* ENABLE_REGEX */
     }
     
-    if (not_equal) {
-      const char *msg_type_str;
+    if (not_equal) {      
       switch(master_test->msg_type) {
 #if ENABLE_REGEX
       case CK_MSG_REGEXP:
@@ -531,7 +533,6 @@ START_TEST(test_check_failure_msgs)
         msg_type_str = "";
       }
 
-      char emsg[MAXSTR];
       snprintf(emsg, MAXSTR - 1,"For test %d:%s:%s Expected%s '%s', got '%s'",
                i, master_test->tcname, master_test->test_name, msg_type_str,
                expected_msg, got_msg);
@@ -543,7 +544,7 @@ START_TEST(test_check_failure_msgs)
        * '%' found, else they will result in odd formatting
        * in ck_abort_msg().
        */
-      char *emsg_escaped = escape_percent(emsg, MAXSTR);
+      emsg_escaped = escape_percent(emsg, MAXSTR);
 
       ck_abort_msg(emsg_escaped);
       free(emsg_escaped);
@@ -675,8 +676,13 @@ START_TEST(test_check_all_msgs)
   const char *got_msg = tr_msg(tr_all_array[_i]);
   master_test_t *master_test = &master_tests[_i];
   const char *expected_msg = master_test->msg;
-
+  char emsg[MAXSTR];
+  const char *msg_type_str;
+  char err_text[256];
+  regex_t re;
+  int reg_err
   unsigned char not_equal = 0;
+  char *emsg_escaped;
 
   switch (master_test->msg_type) {
   case CK_MSG_TEXT:
@@ -686,10 +692,8 @@ START_TEST(test_check_all_msgs)
     break;
 #if ENABLE_REGEX
   case CK_MSG_REGEXP: {
-    regex_t re;
-    int reg_err = regcomp(&re, expected_msg, REG_EXTENDED | REG_NOSUB);
-    if (reg_err) {
-      char err_text[256];
+    reg_err = regcomp(&re, expected_msg, REG_EXTENDED | REG_NOSUB);
+    if (reg_err) {      
       regerror(reg_err, &re, err_text, sizeof(err_text));
       ck_assert_msg(reg_err == 0,
                 "For test %d:%s:%s Expected regexp '%s', but regcomp returned error '%s'",
@@ -706,8 +710,7 @@ START_TEST(test_check_all_msgs)
 #endif /* ENABLE_REGEX */
   }
 
-  if (not_equal) {
-    const char *msg_type_str;
+  if (not_equal) {    
     switch(master_test->msg_type) {
 #if ENABLE_REGEX
     case CK_MSG_REGEXP:
@@ -718,7 +721,6 @@ START_TEST(test_check_all_msgs)
       msg_type_str = "";
     }
 
-    char emsg[MAXSTR];
     snprintf(emsg, MAXSTR - 1, "For test %i:%s:%s expected%s '%s', got '%s'",
              _i, master_test->tcname, master_test->test_name, msg_type_str,
              expected_msg, got_msg);
@@ -730,7 +732,7 @@ START_TEST(test_check_all_msgs)
     * '%' found, else they will result in odd formatting
     * in ck_abort_msg().
     */
-    char *emsg_escaped = escape_percent(emsg, MAXSTR);
+    emsg_escaped = escape_percent(emsg, MAXSTR);
 
     ck_abort_msg(emsg_escaped);
     free(emsg_escaped);
diff --git a/tests/check_check_sub.c b/tests/check_check_sub.c
index 7ac072a..88a57b6 100644
--- a/tests/check_check_sub.c
+++ b/tests/check_check_sub.c
@@ -29,6 +29,7 @@
 START_TEST(test_lno)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_abort_msg("Failure expected");
 }
@@ -38,6 +39,7 @@ END_TEST
 START_TEST(test_mark_lno)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   mark_point();
   exit(EXIT_FAILURE); /* should fail with mark_point above as line */
@@ -48,6 +50,7 @@ END_TEST
 START_TEST(test_pass)
 {
   record_test_name(tcase_name());
+
   ck_assert_msg(1 == 1, "This test should pass");
   ck_assert_msg(9999, "This test should pass");
 }
@@ -56,6 +59,7 @@ END_TEST
 START_TEST(test_fail_unless)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_unless(1 == 2, "This test should fail");
 }
@@ -64,6 +68,7 @@ END_TEST
 START_TEST(test_fail_if_pass)
 {
   record_test_name(tcase_name());
+
   fail_if(1 == 2, "This test should pass");
   fail_if(0, "This test should pass");
 }
@@ -72,6 +77,7 @@ END_TEST
 START_TEST(test_fail_if_fail)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_if(1 == 1, "This test should fail");
 }
@@ -80,6 +86,7 @@ END_TEST
 START_TEST(test_fail_null_msg)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_unless(2 == 3, NULL);
 }
@@ -99,6 +106,7 @@ END_TEST
 START_TEST(test_fail_if_null_msg)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_if(2 != 3, NULL);
 }
@@ -119,7 +127,9 @@ START_TEST(test_fail_vararg_msg_1)
 {
   int x = 3;
   int y = 4;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_unless(x == y, "%d != %d", x, y);
 }
@@ -129,7 +139,9 @@ START_TEST(test_fail_vararg_msg_2)
 {
   int x = 5;
   int y = 6;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail_if(x != y, "%d != %d", x, y);
 }
@@ -139,7 +151,9 @@ START_TEST(test_fail_vararg_msg_3)
 {
   int x = 7;
   int y = 7;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   fail("%d == %d", x, y);
 }
@@ -161,6 +175,7 @@ END_TEST
 START_TEST(test_ck_abort)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_abort();
 }
@@ -169,6 +184,7 @@ END_TEST
 START_TEST(test_ck_abort_msg)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_abort_msg("Failure expected");
 }
@@ -178,6 +194,7 @@ END_TEST
 START_TEST(test_ck_abort_msg_null)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_abort_msg(NULL);
 }
@@ -205,6 +222,7 @@ END_TEST
 START_TEST(test_ck_assert_null)
 {
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert(0);
 }
@@ -213,7 +231,9 @@ END_TEST
 START_TEST(test_ck_assert_with_mod)
 {
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert(1%f == 1);
 }
@@ -223,7 +243,9 @@ START_TEST(test_ck_assert_int_eq)
 {
   int x = 3;
   int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_int_eq(x, y);
   y++;
   record_failure_line_num(__LINE__);
@@ -235,7 +257,9 @@ START_TEST(test_ck_assert_int_eq_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_eq(3%d, 2%f);
 }
@@ -245,7 +269,9 @@ START_TEST(test_ck_assert_int_ne)
 {
   int x = 3;
   int y = 2;
+
   record_test_name(tcase_name());
+
   ck_assert_int_ne(x, y);
   y++;
   record_failure_line_num(__LINE__);
@@ -257,7 +283,9 @@ START_TEST(test_ck_assert_int_ne_with_mod)
 {
   int d = 2;
   int f = 2;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_ne(3%d, 3%f);
 }
@@ -267,7 +295,9 @@ START_TEST(test_ck_assert_int_lt)
 {
   int x = 2;
   int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_int_lt(x, y);
   record_failure_line_num(__LINE__);
   ck_assert_int_lt(x, x);
@@ -278,7 +308,9 @@ START_TEST(test_ck_assert_int_lt_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_lt(3%d, 3%f);
 }
@@ -288,7 +320,9 @@ START_TEST(test_ck_assert_int_le)
 {
   int x = 2;
   int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_int_le(x, y);
   ck_assert_int_le(x, x);
   record_failure_line_num(__LINE__);
@@ -300,7 +334,9 @@ START_TEST(test_ck_assert_int_le_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_le(3%d, 2%f);
 }
@@ -310,7 +346,9 @@ START_TEST(test_ck_assert_int_gt)
 {
   int x = 2;
   int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_int_gt(y, x);
   record_failure_line_num(__LINE__);
   ck_assert_int_gt(y, y);
@@ -321,7 +359,9 @@ START_TEST(test_ck_assert_int_gt_with_mod)
 {
   int d = 1;
   int f = 2;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_gt(3%d, 3%f);
 }
@@ -331,7 +371,9 @@ START_TEST(test_ck_assert_int_ge)
 {
   int x = 2;
   int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_int_ge(y, x);
   ck_assert_int_ge(y, x);
   record_failure_line_num(__LINE__);
@@ -343,7 +385,9 @@ START_TEST(test_ck_assert_int_ge_with_mod)
 {
   int d = 1;
   int f = 3;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_int_ge(3%d, 4%f);
 }
@@ -353,7 +397,9 @@ START_TEST(test_ck_assert_int_expr)
 {
   int x = 1;
   int y = 0;
+
   record_test_name(tcase_name());
+
   ck_assert_int_eq(x, ++y);
   ck_assert_int_eq(x, y);
 } END_TEST
@@ -362,7 +408,9 @@ START_TEST(test_ck_assert_uint_eq)
 {
   unsigned int x = 3;
   unsigned int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_eq(x, y);
   y++;
   record_failure_line_num(__LINE__);
@@ -374,7 +422,9 @@ START_TEST(test_ck_assert_uint_eq_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_eq(3%d, 1%f);
 }
@@ -384,7 +434,9 @@ START_TEST(test_ck_assert_uint_ne)
 {
   unsigned int x = 3;
   unsigned int y = 2;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_ne(x, y);
   y++;
   record_failure_line_num(__LINE__);
@@ -396,7 +448,9 @@ START_TEST(test_ck_assert_uint_ne_with_mod)
 {
   int d = 1;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_ne(1%d, 1%f);
 }
@@ -406,7 +460,9 @@ START_TEST(test_ck_assert_uint_lt)
 {
   unsigned int x = 2;
   unsigned int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_lt(x, y);
   record_failure_line_num(__LINE__);
   ck_assert_uint_lt(x, x);
@@ -417,7 +473,9 @@ START_TEST(test_ck_assert_uint_lt_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_lt(3%d, 1%f);
 }
@@ -427,7 +485,9 @@ START_TEST(test_ck_assert_uint_le)
 {
   unsigned int x = 2;
   unsigned int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_le(x, y);
   ck_assert_uint_le(x, x);
   record_failure_line_num(__LINE__);
@@ -439,7 +499,9 @@ START_TEST(test_ck_assert_uint_le_with_mod)
 {
   int d = 2;
   int f = 1;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_le(3%d, 1%f);
 }
@@ -449,7 +511,9 @@ START_TEST(test_ck_assert_uint_gt)
 {
   unsigned int x = 2;
   unsigned int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_gt(y, x);
   record_failure_line_num(__LINE__);
   ck_assert_uint_gt(y, y);
@@ -460,7 +524,9 @@ START_TEST(test_ck_assert_uint_gt_with_mod)
 {
   int d = 1;
   int f = 2;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_gt(1%d, 3%f);
 }
@@ -470,7 +536,9 @@ START_TEST(test_ck_assert_uint_ge)
 {
   unsigned int x = 2;
   unsigned int y = 3;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_ge(y, x);
   ck_assert_uint_ge(y, x);
   record_failure_line_num(__LINE__);
@@ -482,7 +550,9 @@ START_TEST(test_ck_assert_uint_ge_with_mod)
 {
   int d = 1;
   int f = 2;
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_uint_ge(1%d, 3%f);
 }
@@ -492,17 +562,20 @@ START_TEST(test_ck_assert_uint_expr)
 {
   unsigned int x = 1;
   unsigned int y = 0;
+
   record_test_name(tcase_name());
+
   ck_assert_uint_eq(x, ++y);
   ck_assert_uint_eq(x, y);
 } END_TEST
 
 START_TEST(test_ck_assert_float_eq)
 {
-  record_test_name(tcase_name());
-
   float x = 1.1f;
   float y = 1.1f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_eq(x, y);
   y+=0.1f;
   record_failure_line_num(__LINE__);
@@ -512,10 +585,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_eq_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_eq(3%d, 2%f);
 }
@@ -523,10 +597,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ne)
 {
-  record_test_name(tcase_name());
-
   float x = 1.1f;
   float y = 1.2f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_ne(x, y);
   y = x;
   record_failure_line_num(__LINE__);
@@ -536,10 +611,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ne_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_ne(1%d, 1%f);
 }
@@ -547,10 +623,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_lt)
 {
-  record_test_name(tcase_name());
-
   float x = 2.0f;
   float y = 2.5f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_lt(x, y);
   y-=1.0f;
   record_failure_line_num(__LINE__);
@@ -560,10 +637,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_lt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_lt(3%d, 2%f);
 }
@@ -571,10 +649,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_le)
 {
-  record_test_name(tcase_name());
-
   float x = 2.0f;
   float y = 2.5f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_le(x, y);
   ck_assert_float_le(x, x);
   y-=1.0f;
@@ -585,10 +664,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_le_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_le(3%d, 2%f);
 }
@@ -596,10 +676,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_gt)
 {
-  record_test_name(tcase_name());
-
   float x = 2.5f;
   float y = 2.0f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_gt(x, y);
   y+=1.0f;
   record_failure_line_num(__LINE__);
@@ -609,10 +690,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_gt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_gt(2%d, 3%f);
 }
@@ -620,10 +702,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ge)
 {
-  record_test_name(tcase_name());
-
   float x = 2.5f;
   float y = 2.0f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_ge(x, y);
   ck_assert_float_ge(x, x);
   y+=1.0f;
@@ -634,10 +717,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ge_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_ge(2%d, 3%f);
 }
@@ -645,12 +729,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_with_expr)
 {
-  record_test_name(tcase_name());
-
   float x[] = {NAN, 1.1f, 1.1f, 1.2f, 1.2f, NAN};
   float y = 1.1f;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_float_eq(x[i++], y);
   ck_assert_float_eq(x[i++], y);
@@ -681,11 +765,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_eq_tol)
 {
-  record_test_name(tcase_name());
-
   float x = 0.0001f;
   float y = 0.0003f;
   float t = 0.001f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_eq_tol(x, y, t);
   ck_assert_float_eq_tol(x, x, t);
   x*=10.0f;
@@ -700,11 +785,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_eq_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_eq_tol(3%d, 2%f, 2%p);
 }
@@ -712,11 +798,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ne_tol)
 {
-  record_test_name(tcase_name());
-
   float x = 0.0001f;
   float y = 0.0002f;
   float t = 0.0001f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_ne_tol(x, y, t);
   x*=10.0f;
   y*=10.0f;
@@ -730,11 +817,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ne_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_ne_tol(3%d, 3%f, 3%p);
 }
@@ -742,11 +830,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ge_tol)
 {
-  record_test_name(tcase_name());
-
   float x = 0.001f;
   float y = 0.003f;
   float t = 0.001f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_ge_tol(y, x, t);
   ck_assert_float_ge_tol(x, x, t);
   ck_assert_float_ge_tol(y, y, t);
@@ -763,11 +852,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_ge_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_ge_tol(2%d, 3%f, 3%p);
 }
@@ -775,11 +865,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_le_tol)
 {
-  record_test_name(tcase_name());
-
   float x = 0.001f;
   float y = 0.003f;
   float t = 0.001f;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_le_tol(x, y, t);
   ck_assert_float_le_tol(x, x, t);
   ck_assert_float_le_tol(y, y, t);
@@ -796,11 +887,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_le_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_le_tol(3%d, 2%f, 3%p);
 }
@@ -808,13 +900,13 @@ END_TEST
 
 START_TEST(test_ck_assert_float_tol_with_expr)
 {
-  record_test_name(tcase_name());
-
   float x[] = {NAN, 1.1f, 1.1f, 1.2f, 1.2f, NAN};
   float y = 1.1f;
   float t = 0.01f;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_float_eq_tol(x[i++], y, t);
   ck_assert_float_eq_tol(x[i++], y, t);
@@ -837,12 +929,13 @@ END_TEST
 
 START_TEST(test_ck_assert_float_finite)
 {
+  float x = 0.0001f;
+  float t = 1.0f;
+
   record_test_name(tcase_name());
 
-  float x = 0.0001f;
   ck_assert_float_finite(x);
   // MS VS doesn't allow explicit division by zero
-  float t = 1.0f;
   x = 1.0f / (1.0f - t);
   record_failure_line_num(__LINE__);
   ck_assert_float_finite(x);
@@ -851,11 +944,12 @@ END_TEST
 
 START_TEST(test_ck_assert_float_finite_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   float t = 1.0f;
   float x = 1.0f / (1.0f - t);
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_float_finite(x*(1%d));
 }
@@ -863,10 +957,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_infinite)
 {
-  record_test_name(tcase_name());
-
   float t = 1.0f;
   float x = 1.0f / (1.0f - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_float_infinite(x);
   x = -1.0f / (1.0f - t);
   ck_assert_float_infinite(x);
@@ -878,9 +973,10 @@ END_TEST
 
 START_TEST(test_ck_assert_float_infinite_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_float_infinite(2%d);
 }
@@ -888,10 +984,11 @@ END_TEST
 
 START_TEST(test_ck_assert_float_nan)
 {
-  record_test_name(tcase_name());
-
   float t = 1.0f;
   float x = 0.0f / (1.0f - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_float_nan(x);
   x = 1.0f / (1.0f - t);
   record_failure_line_num(__LINE__);
@@ -901,9 +998,10 @@ END_TEST
 
 START_TEST(test_ck_assert_float_nan_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_float_nan(2%d);
 }
@@ -911,40 +1009,49 @@ END_TEST
 
 START_TEST(test_ck_assert_float_nonnan)
 {
+  float x = 0.0f;
+  float t = 1.0f;
+
   record_test_name(tcase_name());
 
-  float x = 0.0f;
   ck_assert_float_nonnan(x);
 #if ENABLE_REGEX
-  float t = 1.0f;
   x = 0.0f / (1.0f - t);
   record_failure_line_num(__LINE__);
   ck_assert_float_nonnan(x);
+#else
+  (void)t; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_float_nonnan_with_mod)
 {
+  int s = 2;
+  float t = 1.0f;
+  float x;
+
   record_test_name(tcase_name());
 
-  int s = 2;
   ck_assert_float_nonnan(2%s);
 #if ENABLE_REGEX
-  float t = 1.0f;
-  float x = 0.0f / (1.0f - t);
+  x = 0.0f / (1.0f - t);
   record_failure_line_num(__LINE__);
   ck_assert_float_nonnan((2%s)*x);
+#else
+  (void)x; /* unused */
+  (void)t; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_float_nan_and_inf_with_expr)
 {
-  record_test_name(tcase_name());
-
   float x[] = {0.0f, 0.0f, INFINITY, INFINITY, NAN, NAN, 0.0f, 0.0f, NAN};
   int i = 0;
+
+  record_test_name(tcase_name());
+
   ck_assert_float_finite(x[i++]);
   ck_assert_float_finite(x[i++]);
   ck_assert_float_infinite(x[i++]);
@@ -958,10 +1065,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_eq)
 {
-  record_test_name(tcase_name());
-
   double x = 1.1;
   double y = 1.1;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_eq(x, y);
   y+=0.1;
   record_failure_line_num(__LINE__);
@@ -971,10 +1079,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_eq_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_eq(3%d, 2%f);
 }
@@ -982,19 +1091,21 @@ END_TEST
 
 START_TEST(test_ck_assert_double_eq_with_promotion)
 {
-  record_test_name(tcase_name());
-
   float x = 0.1;
   double y = x;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_eq(x, y);
 }
 END_TEST
 
 START_TEST(test_ck_assert_double_eq_with_conv)
 {
+  float x = 0.1;
+
   record_test_name(tcase_name());
 
-  float x = 0.1;
   record_failure_line_num(__LINE__);
   ck_assert_double_eq(x, 0.1);
 }
@@ -1002,10 +1113,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ne)
 {
-  record_test_name(tcase_name());
-
   double x = 1.1;
   double y = 1.2;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_ne(x, y);
   y = x;
   record_failure_line_num(__LINE__);
@@ -1015,10 +1127,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ne_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_ne(1%d, 1%f);
 }
@@ -1026,10 +1139,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_lt)
 {
-  record_test_name(tcase_name());
-
   double x = 2.0;
   double y = 2.5;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_lt(x, y);
   y-=1;
   record_failure_line_num(__LINE__);
@@ -1039,10 +1153,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_lt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_lt(3%d, 2%f);
 }
@@ -1050,10 +1165,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_le)
 {
-  record_test_name(tcase_name());
-
   double x = 2.0;
   double y = 2.5;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_le(x, y);
   ck_assert_double_le(x, x);
   y-=1;
@@ -1064,10 +1180,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_le_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_le(3%d, 2%f);
 }
@@ -1075,10 +1192,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_gt)
 {
-  record_test_name(tcase_name());
-
   double x = 2.5;
   double y = 2.0;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_gt(x, y);
   y+=1;
   record_failure_line_num(__LINE__);
@@ -1088,10 +1206,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_gt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_gt(2%d, 3%f);
 }
@@ -1099,10 +1218,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ge)
 {
-  record_test_name(tcase_name());
-
   double x = 2.5;
   double y = 2.0;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_ge(x, y);
   ck_assert_double_ge(x, x);
   y+=1;
@@ -1113,10 +1233,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ge_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_ge(2%d, 3%f);
 }
@@ -1124,12 +1245,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_with_expr)
 {
-  record_test_name(tcase_name());
-
   double x[] = {NAN, 1.1, 1.1, 1.2, 1.2, NAN};
   double y = 1.1;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_double_eq(x[i++], y);
   ck_assert_double_eq(x[i++], y);
@@ -1160,11 +1281,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_eq_tol)
 {
-  record_test_name(tcase_name());
-
   double x = 0.0001;
   double y = 0.0002;
   double t = 0.001;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_eq_tol(x, y, t);
   ck_assert_double_eq_tol(x, x, t);
   x*=10;
@@ -1179,11 +1301,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_eq_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_eq_tol(3%d, 2%f, 2%p);
 }
@@ -1191,11 +1314,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ne_tol)
 {
-  record_test_name(tcase_name());
-
   double x = 0.0001;
   double y = 0.0002;
   double t = 0.0001;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_ne_tol(x, y, t);
   x*=10;
   y*=10;
@@ -1209,11 +1333,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ne_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_ne_tol(3%d, 3%f, 3%p);
 }
@@ -1221,11 +1346,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ge_tol)
 {
-  record_test_name(tcase_name());
-
   double x = 0.001;
   double y = 0.003;
   double t = 0.001;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_ge_tol(y, x, t);
   ck_assert_double_ge_tol(x, x, t);
   ck_assert_double_ge_tol(y, y, t);
@@ -1242,11 +1368,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_ge_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_ge_tol(2%d, 3%f, 3%p);
 }
@@ -1254,11 +1381,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_le_tol)
 {
-  record_test_name(tcase_name());
-
   double x = 0.001;
   double y = 0.003;
   double t = 0.001;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_le_tol(x, y, t);
   ck_assert_double_le_tol(x, x, t);
   ck_assert_double_le_tol(y, y, t);
@@ -1275,11 +1403,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_le_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_le_tol(3%d, 2%f, 3%p);
 }
@@ -1287,13 +1416,13 @@ END_TEST
 
 START_TEST(test_ck_assert_double_tol_with_expr)
 {
-  record_test_name(tcase_name());
-
   double x[] = {NAN, 1.1, 1.1, 1.2, 1.2, NAN};
   double y = 1.1;
   double t = 0.01;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_double_eq_tol(x[i++], y, t);
   ck_assert_double_eq_tol(x[i++], y, t);
@@ -1316,12 +1445,13 @@ END_TEST
 
 START_TEST(test_ck_assert_double_finite)
 {
+  double x = 0.0001;
+  double t = 1;
+
   record_test_name(tcase_name());
 
-  double x = 0.0001;
   ck_assert_double_finite(x);
   // MS VS doesn't allow explicit division by zero
-  double t = 1;
   x = 1.0 / (1.0 - t);
   record_failure_line_num(__LINE__);
   ck_assert_double_finite(x);
@@ -1330,11 +1460,12 @@ END_TEST
 
 START_TEST(test_ck_assert_double_finite_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   double t = 1;
   double x = 1.0 / (1.0 - t);
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_double_finite(x*(1%d));
 }
@@ -1342,10 +1473,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_infinite)
 {
-  record_test_name(tcase_name());
-
   double t = 1;
   double x = 1.0 / (1.0 - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_double_infinite(x);
   x = -1.0 / (1.0 - t);
   ck_assert_double_infinite(x);
@@ -1357,9 +1489,10 @@ END_TEST
 
 START_TEST(test_ck_assert_double_infinite_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_double_infinite(2%d);
 }
@@ -1367,10 +1500,11 @@ END_TEST
 
 START_TEST(test_ck_assert_double_nan)
 {
-  record_test_name(tcase_name());
-
   double t = 1;
   double x = 0.0 / (1.0 - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_double_nan(x);
   x = 1.0 / (1.0 - t);
   record_failure_line_num(__LINE__);
@@ -1380,9 +1514,10 @@ END_TEST
 
 START_TEST(test_ck_assert_double_nan_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_double_nan(2%d);
 }
@@ -1390,40 +1525,49 @@ END_TEST
 
 START_TEST(test_ck_assert_double_nonnan)
 {
+  double x = 0;
+  double t = 1;
+
   record_test_name(tcase_name());
 
-  double x = 0;
   ck_assert_double_nonnan(x);
 #if ENABLE_REGEX
-  double t = 1;
   x = 0.0 / (1.0 - t);
   record_failure_line_num(__LINE__);
   ck_assert_double_nonnan(x);
+#else
+  (void)t; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_double_nonnan_with_mod)
 {
+  int s = 2;
+  double t = 1.0;
+  double x;
+
   record_test_name(tcase_name());
 
-  int s = 2;
   ck_assert_double_nonnan(2%s);
 #if ENABLE_REGEX
-  double t = 1.0;
-  double x = 0.0 / (1.0 - t);
+  x = 0.0 / (1.0 - t);
   record_failure_line_num(__LINE__);
   ck_assert_double_nonnan((2%s)*x);
+#else
+  (void)t; /* unused */
+  (void)x; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_double_nan_and_inf_with_expr)
 {
-  record_test_name(tcase_name());
-
   double x[] = {0.0, 0.0, INFINITY, INFINITY, NAN, NAN, 0.0, 0.0, NAN};
   int i = 0;
+
+  record_test_name(tcase_name());
+
   ck_assert_double_finite(x[i++]);
   ck_assert_double_finite(x[i++]);
   ck_assert_double_infinite(x[i++]);
@@ -1437,10 +1581,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq)
 {
-  record_test_name(tcase_name());
-
   long double x = 1.1l;
   long double y = 1.1l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_eq(x, y);
   y+=0.1l;
   record_failure_line_num(__LINE__);
@@ -1450,10 +1595,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_eq(3%d, 2%f);
 }
@@ -1461,20 +1607,22 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq_with_promotion)
 {
-  record_test_name(tcase_name());
-
   float x = 1.1;
   long double y = x;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_eq(x, y);
 }
 END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq_with_conv)
 {
-  record_test_name(tcase_name());
-
   float x = 1.1;
   long double y = x;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_eq(x, y);
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_eq(x, 1.1);
@@ -1483,10 +1631,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ne)
 {
-  record_test_name(tcase_name());
-
   long double x = 1.1l;
   long double y = 1.2l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_ne(x, y);
   y = x;
   record_failure_line_num(__LINE__);
@@ -1496,10 +1645,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ne_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_ne(1%d, 1%f);
 }
@@ -1507,10 +1657,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_lt)
 {
-  record_test_name(tcase_name());
-
   long double x = 2.0l;
   long double y = 2.5l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_lt(x, y);
   y-=1.0l;
   record_failure_line_num(__LINE__);
@@ -1520,10 +1671,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_lt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_lt(3%d, 2%f);
 }
@@ -1531,10 +1683,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_le)
 {
-  record_test_name(tcase_name());
-
   long double x = 2.0l;
   long double y = 2.5l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_le(x, y);
   ck_assert_ldouble_le(x, x);
   y-=1.0l;
@@ -1545,10 +1698,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_le_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_le(3%d, 2%f);
 }
@@ -1556,10 +1710,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_gt)
 {
-  record_test_name(tcase_name());
-
   long double x = 2.5l;
   long double y = 2.0l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_gt(x, y);
   y+=1.0l;
   record_failure_line_num(__LINE__);
@@ -1569,10 +1724,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_gt_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_gt(2%d, 3%f);
 }
@@ -1580,10 +1736,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ge)
 {
-  record_test_name(tcase_name());
-
   long double x = 2.5l;
   long double y = 2.0l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_ge(x, y);
   ck_assert_ldouble_ge(x, x);
   y+=1.0l;
@@ -1594,10 +1751,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ge_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_ge(2%d, 3%f);
 }
@@ -1605,12 +1763,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_with_expr)
 {
-  record_test_name(tcase_name());
-
   long double x[] = {NAN, 1.1l, 1.1l, 1.2l, 1.2l, NAN};
   long double y = 1.1l;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_ldouble_eq(x[i++], y);
   ck_assert_ldouble_eq(x[i++], y);
@@ -1641,11 +1799,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq_tol)
 {
-  record_test_name(tcase_name());
-
   long double x = 0.0001l;
   long double y = 0.0002l;
   long double t = 0.001l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_eq_tol(x, y, t);
   ck_assert_ldouble_eq_tol(x, x, t);
   x*=10.0l;
@@ -1660,11 +1819,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_eq_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_eq_tol(3%d, 2%f, 2%p);
 }
@@ -1672,11 +1832,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ne_tol)
 {
-  record_test_name(tcase_name());
-
   long double x = 0.0001l;
   long double y = 0.0002l;
   long double t = 0.0001l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_ne_tol(x, y, t);
   x*=10.0l;
   y*=10.0l;
@@ -1690,11 +1851,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ne_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_ne_tol(3%d, 3%f, 3%p);
 }
@@ -1702,11 +1864,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ge_tol)
 {
-  record_test_name(tcase_name());
-
   long double x = 0.001l;
   long double y = 0.003l;
   long double t = 0.001l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_ge_tol(y, x, t);
   ck_assert_ldouble_ge_tol(x, x, t);
   ck_assert_ldouble_ge_tol(y, y, t);
@@ -1723,11 +1886,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_ge_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_ge_tol(2%d, 3%f, 3%p);
 }
@@ -1735,11 +1899,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_le_tol)
 {
-  record_test_name(tcase_name());
-
   long double x = 0.001l;
   long double y = 0.003l;
   long double t = 0.001l;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_le_tol(x, y, t);
   ck_assert_ldouble_le_tol(x, x, t);
   ck_assert_ldouble_le_tol(y, y, t);
@@ -1756,11 +1921,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_le_tol_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   int f = 2;
   int p = 2;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_le_tol(3%d, 2%f, 3%p);
 }
@@ -1768,13 +1934,13 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_tol_with_expr)
 {
-  record_test_name(tcase_name());
-
   long double x[] = {NAN, 1.1l, 1.1l, 1.2l, 1.2l, NAN};
   long double y = 1.1l;
   long double t = 0.01l;
   int i;
 
+  record_test_name(tcase_name());
+
   i = 1;
   ck_assert_ldouble_eq_tol(x[i++], y, t);
   ck_assert_ldouble_eq_tol(x[i++], y, t);
@@ -1797,12 +1963,13 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_finite)
 {
+  long double x = 0.0001l;
+  long double t = 1.0l;
+
   record_test_name(tcase_name());
 
-  long double x = 0.0001l;
   ck_assert_ldouble_finite(x);
   // MS VS doesn't allow explicit division by zero
-  long double t = 1.0l;
   x = 1.0l / (1.0l - t);
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_finite(x);
@@ -1811,11 +1978,12 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_finite_with_mod)
 {
-  record_test_name(tcase_name());
-
   int d = 2;
   long double t = 1.0l;
   long double x = 1.0l / (1.0l - t);
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_finite(x*(1%d));
 }
@@ -1823,10 +1991,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_infinite)
 {
-  record_test_name(tcase_name());
-
   long double t = 1.0l;
   long double x = 1.0l / (1.0l - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_infinite(x);
   x = -1.0l / (1.0l - t);
   ck_assert_ldouble_infinite(x);
@@ -1838,9 +2007,10 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_infinite_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_infinite(2%d);
 }
@@ -1848,10 +2018,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_nan)
 {
-  record_test_name(tcase_name());
-
   long double t = 1.0l;
   long double x = 0.0l / (1.0l - t);
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_nan(x);
   x = 1.0l / (1.0l - t);
   record_failure_line_num(__LINE__);
@@ -1861,9 +2032,10 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_nan_with_mod)
 {
+  int d = 2;
+
   record_test_name(tcase_name());
 
-  int d = 2;
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_nan(2%d);
 }
@@ -1871,40 +2043,49 @@ END_TEST
 
 START_TEST(test_ck_assert_ldouble_nonnan)
 {
+  long double x = 0.0l;
+  long double t = 1.0l;
+
   record_test_name(tcase_name());
 
-  long double x = 0.0l;
   ck_assert_ldouble_nonnan(x);
 #if ENABLE_REGEX
-  long double t = 1.0l;
   x = 0.0l / (1.0l - t);
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_nonnan(x);
+#else
+  (void)t; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_ldouble_nonnan_with_mod)
 {
+  int s = 2;
+  long double t = 1.0l;
+  long double x;
+
   record_test_name(tcase_name());
 
-  int s = 2;
   ck_assert_ldouble_nonnan(2%s);
 #if ENABLE_REGEX
-  long double t = 1.0l;
-  long double x = 0.0l / (1.0l - t);
+  x = 0.0l / (1.0l - t);
   record_failure_line_num(__LINE__);
   ck_assert_ldouble_nonnan((2%s)*x);
+#else
+  (void)t; /* unused */
+  (void)x; /* unused */
 #endif
 }
 END_TEST
 
 START_TEST(test_ck_assert_ldouble_nan_and_inf_with_expr)
 {
-  record_test_name(tcase_name());
-
   long double x[] = {0.0l, 0.0l, INFINITY, INFINITY, NAN, NAN, 0.0l, 0.0l, NAN};
   int i = 0;
+
+  record_test_name(tcase_name());
+
   ck_assert_ldouble_finite(x[i++]);
   ck_assert_ldouble_finite(x[i++]);
   ck_assert_ldouble_infinite(x[i++]);
@@ -1934,9 +2115,10 @@ START_TEST(test_percent_n_escaped)
 
 START_TEST(test_ck_assert_str_eq)
 {
+  const char *s = "test2";
+
   record_test_name(tcase_name());
 
-  const char *s = "test2";
   ck_assert_str_eq("test2", s);
   record_failure_line_num(__LINE__);
   ck_assert_str_eq("test1", s);
@@ -1945,10 +2127,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_eq_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = NULL;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_eq(t, s);
 }
@@ -1956,10 +2139,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_ne)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test2";
   const char *t = "test1";
+
+  record_test_name(tcase_name());
+
   ck_assert_str_ne(t, s);
   t = "test2";
   record_failure_line_num(__LINE__);
@@ -1969,10 +2153,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_ne_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = "test";
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_ne(t, s);
 }
@@ -1980,10 +2165,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_lt)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test1";
   const char *t = "test2";
+
+  record_test_name(tcase_name());
+
   ck_assert_str_lt(s, t);
   record_failure_line_num(__LINE__);
   ck_assert_str_lt(s, s);
@@ -1992,10 +2178,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_lt_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = "test";
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_lt(s, t);
 }
@@ -2003,10 +2190,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_le)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test1";
   const char *t = "test2";
+
+  record_test_name(tcase_name());
+
   ck_assert_str_le(s, t);
   ck_assert_str_le(s, s);
   record_failure_line_num(__LINE__);
@@ -2016,10 +2204,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_le_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = NULL;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_le(t, s);
 }
@@ -2027,10 +2216,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_gt)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test1";
   const char *t = "test2";
+
+  record_test_name(tcase_name());
+
   ck_assert_str_gt(t, s);
   record_failure_line_num(__LINE__);
   ck_assert_str_gt(t, t);
@@ -2039,10 +2229,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_gt_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = "test";
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_gt(t, s);
 }
@@ -2050,10 +2241,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_ge)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test1";
   const char *t = "test2";
+
+  record_test_name(tcase_name());
+
   ck_assert_str_ge(t, s);
   ck_assert_str_ge(t, t);
   record_failure_line_num(__LINE__);
@@ -2063,10 +2255,11 @@ END_TEST
 
 START_TEST(test_ck_assert_str_ge_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = NULL;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_str_ge(s, t);
 }
@@ -2074,11 +2267,12 @@ END_TEST
 
 START_TEST(test_ck_assert_str_expr)
 {
-  record_test_name(tcase_name());
-
   const char *s = "test1";
   const char *t[] = { "test1", "test2" };
   int i = -1;
+
+  record_test_name(tcase_name());
+
   ck_assert_str_eq(s, t[++i]);
   ck_assert_str_eq(s, t[i]);
 }
@@ -2086,9 +2280,10 @@ END_TEST
 
 START_TEST(test_ck_assert_pstr_eq)
 {
+  const char *s = "test";
+
   record_test_name(tcase_name());
 
-  const char *s = "test";
   ck_assert_pstr_eq("test", s);
   ck_assert_pstr_eq(NULL, NULL);
   record_failure_line_num(__LINE__);
@@ -2098,10 +2293,11 @@ END_TEST
 
 START_TEST(test_ck_assert_pstr_eq_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *t = "test";
   const char *s = NULL;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_pstr_eq(t, s);
 }
@@ -2109,10 +2305,11 @@ END_TEST
 
 START_TEST(test_ck_assert_pstr_ne)
 {
-  record_test_name(tcase_name());
-
   const char *t = "test1";
   const char *s = "test2";
+
+  record_test_name(tcase_name());
+
   ck_assert_pstr_ne(t, s);
   ck_assert_pstr_ne(t, NULL);
   t = "test2";
@@ -2123,10 +2320,11 @@ END_TEST
 
 START_TEST(test_ck_assert_pstr_ne_with_null)
 {
-  record_test_name(tcase_name());
-
   const char *s = NULL;
   const char *t = NULL;
+
+  record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_pstr_ne(t, s);
 }
@@ -2136,7 +2334,9 @@ START_TEST(test_ck_assert_ptr_eq)
 {
   int * x = (int*)0x1;
   int * y = (int*)0x2;
+
   record_test_name(tcase_name());
+
   ck_assert_ptr_eq(NULL, NULL);
   ck_assert_ptr_eq(x,    x);
   record_failure_line_num(__LINE__);
@@ -2149,7 +2349,9 @@ START_TEST(test_ck_assert_ptr_ne)
   int * x = (int*)0x1;
   int * y = (int*)0x2;
   int * z = x;
+
   record_test_name(tcase_name());
+
   ck_assert_ptr_ne(x,    y);
   ck_assert_ptr_ne(x,    NULL);
   ck_assert_ptr_ne(NULL, y);
@@ -2160,10 +2362,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ptr_null)
 {
-  record_test_name(tcase_name());
-
   void* x = (void*)0x1;
   void* y = NULL;
+
+  record_test_name(tcase_name());
+
   ck_assert_ptr_null(y);
   record_failure_line_num(__LINE__);
   ck_assert_ptr_null(x);
@@ -2172,10 +2375,11 @@ END_TEST
 
 START_TEST(test_ck_assert_ptr_nonnull)
 {
-  record_test_name(tcase_name());
-
   void* x = NULL;
   void* y = (void*)0x1;
+
+  record_test_name(tcase_name());
+
   ck_assert_ptr_nonnull(y);
   record_failure_line_num(__LINE__);
   ck_assert_ptr_nonnull(x);
@@ -2185,7 +2389,9 @@ END_TEST
 START_TEST(test_ck_assert_mem_eq)
 {
   const char *s = "\x00\x00\x00\x00\x02";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_eq("\x00\x00\x00\x00\x02", s, 5);
   record_failure_line_num(__LINE__);
   ck_assert_mem_eq("\x00\x00\x00\x00\x01", s, 5);
@@ -2196,7 +2402,9 @@ START_TEST(test_ck_assert_mem_ne)
 {
   const char *s = "\x00\x00\x00\x00\x02";
   const char *t = "\x00\x00\x00\x00\x01";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_ne(t, s, 5);
   t = "\x00\x00\x00\x00\x02";
   record_failure_line_num(__LINE__);
@@ -2208,7 +2416,9 @@ START_TEST(test_ck_assert_mem_lt)
 {
   const char *s = "\x00\x00\x00\x00\x01";
   const char *t = "\x00\x00\x00\x00\x02";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_lt(s, t, 5);
   record_failure_line_num(__LINE__);
   ck_assert_mem_lt(s, s, 5);
@@ -2219,7 +2429,9 @@ START_TEST(test_ck_assert_mem_le)
 {
   const char *s = "\x00\x00\x00\x00\x01";
   const char *t = "\x00\x00\x00\x00\x02";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_le(s, t, 5);
   ck_assert_mem_le(s, s, 5);
   record_failure_line_num(__LINE__);
@@ -2231,7 +2443,9 @@ START_TEST(test_ck_assert_mem_gt)
 {
   const char *s = "\x00\x00\x00\x00\x01";
   const char *t = "\x00\x00\x00\x00\x02";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_gt(t, s, 5);
   record_failure_line_num(__LINE__);
   ck_assert_mem_gt(t, t, 5);
@@ -2242,7 +2456,9 @@ START_TEST(test_ck_assert_mem_ge)
 {
   const char *s = "\x00\x00\x00\x00\x01";
   const char *t = "\x00\x00\x00\x00\x02";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_ge(t, s, 5);
   ck_assert_mem_ge(t, t, 5);
   record_failure_line_num(__LINE__);
@@ -2254,7 +2470,9 @@ START_TEST(test_ck_assert_mem_zerolen)
 {
   const char *s = "\x00\x00\x00\x00\x02";
   const char *t = "\x00\x00\x00\x00\x01";
+
   record_test_name(tcase_name());
+
   ck_assert_mem_eq(t, s, 0);
 }
 END_TEST
@@ -2263,7 +2481,9 @@ START_TEST(test_ck_assert_mem_eq_exact)
 {
   const char *s = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02";
   const char *t = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01";
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_mem_eq(t, s, 64);
 }
@@ -2273,7 +2493,9 @@ START_TEST(test_ck_assert_mem_eq_longer)
 {
   const char *s = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02";
   const char *t = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01";
+
   record_test_name(tcase_name());
+
   record_failure_line_num(__LINE__);
   ck_assert_mem_eq(t, s, 65);
 }
@@ -2481,8 +2703,10 @@ END_TEST
 
 START_TEST(test_null_2)
 {
-  record_test_name(tcase_name());
   SRunner *sr = srunner_create(NULL);
+
+  record_test_name(tcase_name());
+
   srunner_run_all (sr, CK_NORMAL);
   srunner_free (sr);
   ck_assert_int_eq(suite_tcase(NULL, NULL), 0);
@@ -2693,8 +2917,11 @@ void exit_handler ()
 
 START_TEST(test_ignore_exit_handlers)
 {
+  int result;
+
   record_test_name(tcase_name());
-  int result = atexit(exit_handler);
+
+  result = atexit(exit_handler);
   if(result != 0)
   {
     ck_abort_msg("Failed to set an exit handler, test cannot proceed");
diff --git a/tests/check_list.c b/tests/check_list.c
index 6905e82..60b8b7f 100644
--- a/tests/check_list.c
+++ b/tests/check_list.c
@@ -170,11 +170,11 @@ START_TEST(test_contains)
 
     char otherData[] = "other";
     char goalData[] = "goal";
+    int index;
 
     ck_assert_msg (check_list_contains(lp, goalData) == 0,
                        "The goal data should not be in the list yet");
 
-    int index;
     for(index = 0; index < 10; index++)
     {
         check_list_add_end (lp, otherData);