Fix trivial warnings from 'make check'

bk: 59f6e6cbRNeYCmn0CBqtlXccTr5Qkg

diff --git a/ChangeLog b/ChangeLog
index e117bfcd1900c9b5f9ae4fe6d7e7fff1f7ebdd6b..399f09a5879d895ab5b80d40d095fac60e6ada45 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -50,6 +50,7 @@
 * test_ntp_scanner_LDADD needs ntpd/ntp_io.o.  HStenn.
 * refclock_jjy.c: Add missing "%s" to an msyslog() call.  HStenn.
 * Build ntpq and libntpq.a with NTP_HARD_*FLAGS.  perlinger@ntp.org
+* Fix trivial warnings from 'make check'. perlinger@ntp.org
 
 ---
 (4.2.8p10) 2017/03/21 Released by Harlan Stenn <stenn@ntp.org>

diff --git a/tests/ntpd/leapsec.c b/tests/ntpd/leapsec.c
index 36ecd39c802ddc3142bef62e4d1bf5940cff81dd..34a6ed76ee6debe3d8ad845855cc6e7d6d98e0b2 100644 (file)
--- a/tests/ntpd/leapsec.c
+++ b/tests/ntpd/leapsec.c
@@ -6,11 +6,15 @@
 #include "ntp_calendar.h"
 #include "ntp_stdlib.h"
 #include "ntp_leapsec.h"
+#include "lib_strbuf.h"
 
 #include "unity.h"
 
 #include <string.h>
 
+extern void    setUp(void);
+extern void    tearDown(void);
+
 #include "test-libntp.h"
 
 static const char leap1 [] =
@@ -231,7 +235,7 @@ static const uint32_t lsec2009 = 3439756800u; // +34, 1 Jan 2009, 00:00:00 utc
 static const uint32_t lsec2012 = 3550089600u; // +35, 1 Jul 2012, 00:00:00 utc
 static const uint32_t lsec2015 = 3644697600u; // +36, 1 Jul 2015, 00:00:00 utc
 
-int stringreader(void* farg)
+static int stringreader(void* farg)
 {
        const char ** cpp = (const char**)farg;
 
@@ -266,40 +270,21 @@ setup_clear_table(void)
        return rc;
 }
 
-
-char *
+#if 0 /* formatting & compare currently not used... */
+static const char *
 CalendarToString(const struct calendar cal)
 {
-       char * ss = malloc (sizeof (char) * 100);
-       char buffer[100] ="";
-
-       *ss = '\0';
-       sprintf(buffer, "%u", cal.year);
-       strcat(ss,buffer);
-       strcat(ss,"-");
-       sprintf(buffer, "%u", (u_int)cal.month);
-       strcat(ss,buffer);
-       strcat(ss,"-");
-       sprintf(buffer, "%u", (u_int)cal.monthday);
-       strcat(ss,buffer);
-       strcat(ss," (");
-       sprintf(buffer, "%u", (u_int) cal.yearday);
-       strcat(ss,buffer);
-       strcat(ss,") ");
-       sprintf(buffer, "%u", (u_int)cal.hour);
-       strcat(ss,buffer);
-       strcat(ss,":");
-       sprintf(buffer, "%u", (u_int)cal.minute);
-       strcat(ss,buffer);
-       strcat(ss,":");
-       sprintf(buffer, "%u", (u_int)cal.second);
-       strcat(ss,buffer);
-       //ss << cal.year << "-" << (u_int)cal.month << "-" << (u_int)cal.monthday << " (" << cal.yearday << ") " << (u_int)cal.hour << ":" << (u_int)cal.minute << ":" << (u_int)cal.second;
-       return ss;
+       char * str;
+
+       LIB_GETBUF(str);
+       snprintf(str, LIB_BUFLENGTH,
+                "%04hu-%02hhu-%02hhu (%hu) %02hhu:%02hhu:%02hhu",
+                cal.year, cal.month, cal.monthday, cal.yearday,
+                cal.hour, cal.minute, cal.second);
+       return str;
 }
 
-
-int
+static int
 IsEqual(const struct calendar expected, const struct calendar actual)
 {
 
@@ -312,16 +297,13 @@ IsEqual(const struct calendar expected, const struct calendar actual)
            && expected.second == actual.second) {
                return TRUE;
        } else {
-               char *p_exp = CalendarToString(expected);
-               char *p_act = CalendarToString(actual);
-
+               const char *p_exp = CalendarToString(expected);
+               const char *p_act = CalendarToString(actual);
                printf("expected: %s but was %s", p_exp, p_act);
-
-               free(p_exp);
-               free(p_act);
                return FALSE;
        }
 }
+#endif /*0*/
 
 //-------------------------
 
@@ -331,15 +313,12 @@ setUp(void)
     ntpcal_set_timefunc(timefunc);
     settime(1970, 1, 1, 0, 0, 0);
     leapsec_ut_pristine();
-
-    return;
 }
 
 void
 tearDown(void)
 {
     ntpcal_set_timefunc(NULL);
-    return;
 }
 
 // =====================================================================
@@ -347,73 +326,63 @@ tearDown(void)
 // =====================================================================
 
 // ----------------------------------------------------------------------
-void
-test_ValidateGood(void)
+extern void test_ValidateGood(void);
+void test_ValidateGood(void)
 {
        const char *cp = leap_ghash;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_GOODHASH, rc);
-       return;
 }
 
 // ----------------------------------------------------------------------
-void
-test_ValidateNoHash(void)
+extern void test_ValidateNoHash(void);
+void test_ValidateNoHash(void)
 {
        const char *cp = leap2;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_NOHASH, rc);
-       return;
 }
 
 // ----------------------------------------------------------------------
-void
-test_ValidateBad(void)
+extern void test_ValidateBad(void);
+void test_ValidateBad(void)
 {
        const char *cp = leap_bhash;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_BADHASH, rc);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
-void
-test_ValidateMalformed(void)
+extern void test_ValidateMalformed(void);
+void test_ValidateMalformed(void)
 {
        const char *cp = leap_mhash;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_BADFORMAT, rc);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
-void
-test_ValidateMalformedShort(void)
+extern void test_ValidateMalformedShort(void);
+void test_ValidateMalformedShort(void)
 {
        const char *cp = leap_shash;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_BADFORMAT, rc);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
-void
-test_ValidateNoLeadZero(void)
+extern void test_ValidateNoLeadZero(void);
+void test_ValidateNoLeadZero(void)
 {
        const char *cp = leap_gthash;
        int         rc = leapsec_validate(stringreader, &cp);
 
        TEST_ASSERT_EQUAL(LSVALID_GOODHASH, rc);
-
-       return;
 }
 
 // =====================================================================
@@ -422,10 +391,10 @@ test_ValidateNoLeadZero(void)
 
 // ----------------------------------------------------------------------
 // test table selection
-void
-test_tableSelect(void)
+extern void test_tableSelect(void);
+void test_tableSelect(void)
 {
-       leap_table_t *pt1, *pt2, *pt3, *pt4;
+    leap_table_t *pt1, *pt2, *pt3;
 
        pt1 = leapsec_get_table(0);
        pt2 = leapsec_get_table(0);
@@ -455,15 +424,12 @@ test_tableSelect(void)
        pt3 = leapsec_get_table(1);
        TEST_ASSERT_EQUAL(pt1, pt2);
        TEST_ASSERT_NOT_EQUAL(pt2, pt3);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // load file & check expiration
-
-void
-test_loadFileExpire(void)
+extern void test_loadFileExpire(void);
+void test_loadFileExpire(void)
 {
        const char *cp = leap1;
        int rc;
@@ -476,15 +442,12 @@ test_loadFileExpire(void)
        TEST_ASSERT_EQUAL(0, rc);
        rc = leapsec_expired(3610569601u, NULL);
        TEST_ASSERT_EQUAL(1, rc);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // load file & check time-to-live
-
-void
-test_loadFileTTL(void)
+extern void test_loadFileTTL(void);
+void test_loadFileTTL(void)
 {
        const char     *cp = leap1;
        int             rc;
@@ -508,8 +471,6 @@ test_loadFileTTL(void)
        // expired since 1 sec
        rc = leapsec_daystolive(limit + 1, &pivot);
        TEST_ASSERT_EQUAL(-1, rc);
-
-       return;
 }
 
 // =====================================================================
@@ -518,8 +479,8 @@ test_loadFileTTL(void)
 
 // ----------------------------------------------------------------------
 // test query in pristine state (bug#2745 misbehaviour)
-void
-test_lsQueryPristineState(void)
+extern void test_lsQueryPristineState(void);
+void test_lsQueryPristineState(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -528,14 +489,12 @@ test_lsQueryPristineState(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // ad-hoc jump: leap second at 2009.01.01 -60days
-void
-test_ls2009faraway(void)
+extern void test_ls2009faraway(void);
+void test_ls2009faraway(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -549,14 +508,12 @@ test_ls2009faraway(void)
        TEST_ASSERT_EQUAL(33, qr.tai_offs);
        TEST_ASSERT_EQUAL(0,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // ad-hoc jump: leap second at 2009.01.01 -1week
-void
-test_ls2009weekaway(void)
+extern void test_ls2009weekaway(void);
+void test_ls2009weekaway(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -570,14 +527,12 @@ test_ls2009weekaway(void)
        TEST_ASSERT_EQUAL(33, qr.tai_offs);
        TEST_ASSERT_EQUAL(1,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_SCHEDULE, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // ad-hoc jump: leap second at 2009.01.01 -1hr
-void
-test_ls2009houraway(void)
+extern void test_ls2009houraway(void);
+void test_ls2009houraway(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -591,14 +546,12 @@ test_ls2009houraway(void)
        TEST_ASSERT_EQUAL(33, qr.tai_offs);
        TEST_ASSERT_EQUAL(1,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_ANNOUNCE, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // ad-hoc jump: leap second at 2009.01.01 -1sec
-void
-test_ls2009secaway(void)
+extern void test_ls2009secaway(void);
+void test_ls2009secaway(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -612,14 +565,12 @@ test_ls2009secaway(void)
        TEST_ASSERT_EQUAL(33, qr.tai_offs);
        TEST_ASSERT_EQUAL(1,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_ALERT, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // ad-hoc jump to leap second at 2009.01.01
-void
-test_ls2009onspot(void)
+extern void test_ls2009onspot(void);
+void test_ls2009onspot(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -633,14 +584,12 @@ test_ls2009onspot(void)
        TEST_ASSERT_EQUAL(34, qr.tai_offs);
        TEST_ASSERT_EQUAL(0,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test handling of the leap second at 2009.01.01 without table
-void
-test_ls2009nodata(void)
+extern void test_ls2009nodata(void);
+void test_ls2009nodata(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -654,14 +603,12 @@ test_ls2009nodata(void)
        TEST_ASSERT_EQUAL(0,  qr.tai_offs);
        TEST_ASSERT_EQUAL(0,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test handling of the leap second at 2009.01.01 with culled data
-void
-test_ls2009limdata(void)
+extern void test_ls2009limdata(void);
+void test_ls2009limdata(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -679,18 +626,15 @@ test_ls2009limdata(void)
        TEST_ASSERT_TRUE(35 >= qr.tai_offs);
        TEST_ASSERT_EQUAL(0,  qr.tai_diff);
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // Far-distance forward jump into a transiton window.
-void
-test_qryJumpFarAhead(void)
+extern void test_qryJumpFarAhead(void);
+void test_qryJumpFarAhead(void)
 {
-       int            rc;
-       leap_result_t  qr;
-       int            last, idx;
+       int             rc;
+       leap_result_t   qr;
        int             mode;
 
        for (mode=0; mode < 2; ++mode) {
@@ -709,10 +653,11 @@ test_qryJumpFarAhead(void)
 
 // ----------------------------------------------------------------------
 // Forward jump into the next transition window
-void test_qryJumpAheadToTransition(void) {
+extern void test_qryJumpAheadToTransition(void);
+void test_qryJumpAheadToTransition(void)
+{
        int             rc;
        leap_result_t   qr;
-       int             last, idx;
        int             mode;
 
        for (mode=0; mode < 2; ++mode) {
@@ -727,18 +672,15 @@ void test_qryJumpAheadToTransition(void) {
                rc = leapsec_query(&qr, lsec2009+1, NULL);
                TEST_ASSERT_EQUAL(TRUE, rc);
        }
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // Forward jump over the next transition window
-void
-test_qryJumpAheadOverTransition(void)
+extern void test_qryJumpAheadOverTransition(void);
+void test_qryJumpAheadOverTransition(void)
 {
        int             rc;
        leap_result_t   qr;
-       int             last, idx;
        int             mode;
 
        for (mode=0; mode < 2; ++mode) {
@@ -753,8 +695,6 @@ test_qryJumpAheadOverTransition(void)
                rc = leapsec_query(&qr, lsec2009+5, NULL);
                TEST_ASSERT_EQUAL(FALSE, rc);
        }
-
-       return;
 }
 
 // =====================================================================
@@ -763,11 +703,10 @@ test_qryJumpAheadOverTransition(void)
 
 // ----------------------------------------------------------------------
 // add dynamic leap second (like from peer/clock)
-void
-test_addDynamic(void)
+extern void test_addDynamic(void);
+void test_addDynamic(void)
 {
        int            rc;
-       leap_result_t  qr;
 
        static const uint32_t insns[] = {
                2982009600u,    //      29      # 1 Jul 1994
@@ -794,15 +733,13 @@ test_addDynamic(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        //leap_table_t  * pt = leapsec_get_table(0);
        //leapsec_dump(pt, (leapsec_dumper)fprintf, stdout);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // add fixed leap seconds (like from network packet)
 #if 0 /* currently unused -- possibly revived later */
-void
-FAILtest_addFixed(void)
+extern void no_test_addFixed(void);
+void no_test_addFixed(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -849,16 +786,14 @@ FAILtest_addFixed(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        //leap_table_t * pt = leapsec_get_table(0);
        //leapsec_dump(pt, (leapsec_dumper)fprintf, stdout);
-
-       return;
 }
 #endif
 
 // ----------------------------------------------------------------------
 // add fixed leap seconds (like from network packet)
 #if 0 /* currently unused -- possibly revived later */
-void
-FAILtest_addFixedExtend(void)
+extern void no_test_addFixedExtend(void);
+void no_test_addFixedExtend(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -900,8 +835,6 @@ FAILtest_addFixedExtend(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        //leap_table_t * pt = leapsec_get_table(FALSE);
        //leapsec_dump(pt, (leapsec_dumper)fprintf, stdout);
-
-       return;
 }
 #endif
 
@@ -910,8 +843,8 @@ FAILtest_addFixedExtend(void)
 // empty table and test queries before / between /after the tabulated
 // values.
 #if 0 /* currently unused -- possibly revived later */
-void
-FAILtest_setFixedExtend(void)
+extern void no_test_setFixedExtend(void);
+void no_test_setFixedExtend(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -947,8 +880,6 @@ FAILtest_setFixedExtend(void)
 
        //leap_table_t * pt = leapsec_get_table(0);
        //leapsec_dump(pt, (leapsec_dumper)fprintf, stdout);
-
-       return;
 }
 #endif
 
@@ -958,7 +889,9 @@ FAILtest_setFixedExtend(void)
 
 // ----------------------------------------------------------------------
 // Check if the offset can be applied to an empty table ONCE
-void test_taiEmptyTable(void) {
+extern void test_taiEmptyTable(void);
+void test_taiEmptyTable(void)
+{
        int rc;
 
        rc = leapsec_autokey_tai(35, lsec2015-30*86400, NULL);
@@ -970,8 +903,8 @@ void test_taiEmptyTable(void) {
 
 // ----------------------------------------------------------------------
 // Check that with fixed entries the operation fails
-void
-test_taiTableFixed(void)
+extern void test_taiTableFixed(void);
+void test_taiTableFixed(void)
 {
        int rc;
 
@@ -980,14 +913,12 @@ test_taiTableFixed(void)
 
        rc = leapsec_autokey_tai(35, lsec2015-30*86400, NULL);
        TEST_ASSERT_EQUAL(FALSE, rc);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test adjustment with a dynamic entry already there
-void
-test_taiTableDynamic(void)
+extern void test_taiTableDynamic(void);
+void test_taiTableDynamic(void)
 {
        int        rc;
        leap_era_t era;
@@ -1010,14 +941,12 @@ test_taiTableDynamic(void)
        TEST_ASSERT_EQUAL(35, era.taiof);
        leapsec_query_era(&era, lsec2015+10, NULL);
        TEST_ASSERT_EQUAL(36, era.taiof);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test adjustment with a dynamic entry already there in dead zone
-void
-test_taiTableDynamicDeadZone(void)
+extern void test_taiTableDynamicDeadZone(void);
+void test_taiTableDynamicDeadZone(void)
 {
        int rc;
 
@@ -1029,8 +958,6 @@ test_taiTableDynamicDeadZone(void)
 
        rc = leapsec_autokey_tai(35, lsec2015+5, NULL);
        TEST_ASSERT_EQUAL(FALSE, rc);
-
-       return;
 }
 
 
@@ -1040,8 +967,8 @@ test_taiTableDynamicDeadZone(void)
 
 // ----------------------------------------------------------------------
 // leap second insert at 2009.01.01, electric mode
-void
-test_ls2009seqInsElectric(void)
+extern void test_ls2009seqInsElectric(void);
+void test_ls2009seqInsElectric(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1081,14 +1008,12 @@ test_ls2009seqInsElectric(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // leap second insert at 2009.01.01, dumb mode
-void
-test_ls2009seqInsDumb(void)
+extern void test_ls2009seqInsDumb(void);
+void test_ls2009seqInsDumb(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1132,15 +1057,12 @@ test_ls2009seqInsDumb(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
-
 // ----------------------------------------------------------------------
 // fake leap second remove at 2009.01.01, electric mode
-void
-test_ls2009seqDelElectric(void)
+extern void test_ls2009seqDelElectric(void);
+void test_ls2009seqDelElectric(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1180,14 +1102,12 @@ test_ls2009seqDelElectric(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // fake leap second remove at 2009.01.01. dumb mode
-void
-test_ls2009seqDelDumb(void)
+extern void test_ls2009seqDelDumb(void);
+void test_ls2009seqDelDumb(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1226,14 +1146,12 @@ test_ls2009seqDelDumb(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // leap second insert at 2012.07.01, electric mode
-void
-test_ls2012seqInsElectric(void)
+extern void test_ls2012seqInsElectric(void);
+void test_ls2012seqInsElectric(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1273,14 +1191,12 @@ test_ls2012seqInsElectric(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // leap second insert at 2012.07.01, dumb mode
-void
-test_ls2012seqInsDumb(void)
+extern void test_ls2012seqInsDumb(void);
+void test_ls2012seqInsDumb(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1326,23 +1242,17 @@ test_ls2012seqInsDumb(void)
        TEST_ASSERT_EQUAL(FALSE, rc);
        TEST_ASSERT_EQUAL(0,             qr.warped   );
        TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test repeated query on empty table in dumb mode
-void
-test_lsEmptyTableDumb(void)
+extern void test_lsEmptyTableDumb(void);
+void test_lsEmptyTableDumb(void)
 {
        int            rc;
        leap_result_t  qr;
 
-       //const
-       time_t pivot;
-       pivot = lsec2012;
-       //      const 
-       //time_t   pivot(lsec2012);
+       const time_t   pivot = lsec2012;
        const uint32_t t0 = lsec2012 - 10;
        const uint32_t tE = lsec2012 + 10;
 
@@ -1355,14 +1265,12 @@ test_lsEmptyTableDumb(void)
                TEST_ASSERT_EQUAL(0,             qr.warped   );
                TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
        }
-
-       return;
 }
 
 // ----------------------------------------------------------------------
 // test repeated query on empty table in electric mode
-void
-test_lsEmptyTableElectric(void)
+extern void test_lsEmptyTableElectric(void);
+void test_lsEmptyTableElectric(void)
 {
        int            rc;
        leap_result_t  qr;
@@ -1370,9 +1278,7 @@ test_lsEmptyTableElectric(void)
        leapsec_electric(1);
        TEST_ASSERT_EQUAL(1, leapsec_electric(-1));
 
-       //const 
-       time_t   pivot;//(lsec2012);
-       pivot = lsec2012;
+       const time_t   pivot = lsec2012;
        const uint32_t t0 = lsec2012 - 10;
        const uint32_t tE = lsec2012 + 10;
 
@@ -1383,6 +1289,4 @@ test_lsEmptyTableElectric(void)
                TEST_ASSERT_EQUAL(0,             qr.warped   );
                TEST_ASSERT_EQUAL(LSPROX_NOWARN, qr.proximity);
        }
-
-       return;
 }

diff --git a/tests/ntpd/ntp_prio_q.c b/tests/ntpd/ntp_prio_q.c
index 4b27157a9fa5fcbff2bda67a5224e5e591fe9469..7741af82f3ff741b5e6a9c4cbebe39e898dbee20 100644 (file)
--- a/tests/ntpd/ntp_prio_q.c
+++ b/tests/ntpd/ntp_prio_q.c
@@ -27,23 +27,25 @@ typedef struct Element
 
 } element;
 
-int
+static int/*BOOL*/
 compare_elements(const void * e1, const void * e2)
 {
-       return ((element*)e1)->number < ((element*)e2)->number;
+       return ((const element*)e1)->number < ((const element*)e2)->number;
 }
 
 /* tests */
 
-void
-test_AllocateDeallocateNode(void) {
+extern void test_AllocateDeallocateNode(void);
+void test_AllocateDeallocateNode(void)
+{
        element* e_ptr = debug_get_node(sizeof(element));
        free_node(e_ptr);
 }
 
 
-void
-test_EmptyQueue(void) {
+extern void test_EmptyQueue(void);
+void test_EmptyQueue(void)
+{
        queue* q = create_queue();
 
        TEST_ASSERT_NOT_NULL(q);
@@ -56,8 +58,9 @@ test_EmptyQueue(void) {
 }
 
 
-void
-test_OneElementQueue(void) {
+extern void test_OneElementQueue(void);
+void test_OneElementQueue(void)
+{
        queue* q = create_queue();
 
        TEST_ASSERT_NOT_NULL(q);
@@ -84,8 +87,9 @@ test_OneElementQueue(void) {
 }
 
 
-void
-test_MultipleElementQueue(void) {
+extern void test_MultipleElementQueue(void);
+void test_MultipleElementQueue(void)
+{
        queue* q = create_queue();
 
        TEST_ASSERT_NOT_NULL(q);
@@ -122,8 +126,9 @@ test_MultipleElementQueue(void) {
 }
 
 
-void
-test_CustomOrderQueue(void) {
+extern void test_CustomOrderQueue(void);
+void test_CustomOrderQueue(void)
+{
        queue* q = debug_create_priority_queue(compare_elements);
        element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
 
@@ -179,8 +184,9 @@ test_CustomOrderQueue(void) {
 }
 
 
-void
-test_DestroyNonEmptyQueue(void) {
+extern void test_DestroyNonEmptyQueue(void);
+void test_DestroyNonEmptyQueue(void)
+{
        queue* q = create_queue();
        element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
 
@@ -201,8 +207,10 @@ test_DestroyNonEmptyQueue(void) {
        destroy_queue(q);
 }
 
-void
-test_AppendQueues(void) {
+
+extern void test_AppendQueues(void);
+void test_AppendQueues(void)
+{
        queue* q1 = create_queue();
        queue* q2 = create_queue();
        queue* q3 = create_queue();

diff --git a/tests/ntpd/ntp_restrict.c b/tests/ntpd/ntp_restrict.c
index 08d236e24df92d6689805e92e95c15433db150d2..7b1a60a049f34c648223c2bab0334ca4b0e63d13 100644 (file)
--- a/tests/ntpd/ntp_restrict.c
+++ b/tests/ntpd/ntp_restrict.c
@@ -5,10 +5,14 @@
 
 #include "unity.h"
 
+extern void setUp(void);
+extern void tearDown(void);
+
 /* Helper functions */
 
-sockaddr_u
-create_sockaddr_u(short sin_family, unsigned short sin_port, char* ip_addr) {
+static sockaddr_u
+create_sockaddr_u(short sin_family, unsigned short sin_port, char* ip_addr)
+{
        sockaddr_u sockaddr;
 
        sockaddr.sa4.sin_family = AF_INET;
@@ -20,14 +24,14 @@ create_sockaddr_u(short sin_family, unsigned short sin_port, char* ip_addr) {
 }
 
 
-void
-setUp(void) {
+void setUp(void)
+{
        init_restrict();
 }
 
 
-void
-tearDown(void) {
+void tearDown(void)
+{
        restrict_u *empty_restrict = malloc(sizeof(restrict_u));
        memset(empty_restrict, 0, sizeof(restrict_u));
 
@@ -56,8 +60,9 @@ tearDown(void) {
 /* Tests */
 
 
-void
-test_RestrictionsAreEmptyAfterInit(void) {
+extern void test_RestrictionsAreEmptyAfterInit(void);
+void test_RestrictionsAreEmptyAfterInit(void)
+{
 
        restrict_u *rl4 = malloc(sizeof(restrict_u));
        restrict_u *rl6 = malloc(sizeof(restrict_u));
@@ -82,8 +87,9 @@ test_RestrictionsAreEmptyAfterInit(void) {
 }
 
 
-void
-test_ReturnsCorrectDefaultRestrictions(void) {
+extern void test_ReturnsCorrectDefaultRestrictions(void);
+void test_ReturnsCorrectDefaultRestrictions(void)
+{
        sockaddr_u sockaddr = create_sockaddr_u(AF_INET,
                54321, "63.161.169.137");
 
@@ -93,8 +99,9 @@ test_ReturnsCorrectDefaultRestrictions(void) {
 }
 
 
-void
-test_HackingDefaultRestriction(void) {
+extern void test_HackingDefaultRestriction(void);
+void test_HackingDefaultRestriction(void)
+{
        /*
        *       We change the flag of the default restriction,
        *       and check if restriction() returns that flag
@@ -116,8 +123,9 @@ test_HackingDefaultRestriction(void) {
 }
 
 
-void
-test_CantRemoveDefaultEntry(void) {
+extern void test_CantRemoveDefaultEntry(void);
+void test_CantRemoveDefaultEntry(void)
+{
        sockaddr_u resaddr = create_sockaddr_u(AF_INET, 54321, "0.0.0.0");
        sockaddr_u resmask = create_sockaddr_u(AF_INET, 54321, "0.0.0.0");
 
@@ -127,8 +135,9 @@ test_CantRemoveDefaultEntry(void) {
 }
 
 
-void
-test_AddingNewRestriction(void) {
+extern void test_AddingNewRestriction(void);
+void test_AddingNewRestriction(void)
+{
        sockaddr_u resaddr = create_sockaddr_u(AF_INET, 54321, "11.22.33.44");
        sockaddr_u resmask = create_sockaddr_u(AF_INET, 54321, "128.0.0.0");
 
@@ -140,8 +149,9 @@ test_AddingNewRestriction(void) {
 }
 
 
-void
-test_TheMostFittingRestrictionIsMatched(void) {
+extern void test_TheMostFittingRestrictionIsMatched(void);
+void test_TheMostFittingRestrictionIsMatched(void)
+{
        sockaddr_u resaddr_target = create_sockaddr_u(AF_INET, 54321, "11.22.33.44");
 
        sockaddr_u resaddr_not_matching = create_sockaddr_u(AF_INET, 54321, "11.99.33.44");
@@ -162,8 +172,9 @@ test_TheMostFittingRestrictionIsMatched(void) {
 }
 
 
-void
-test_DeletedRestrictionIsNotMatched(void) {
+extern void test_DeletedRestrictionIsNotMatched(void);
+void test_DeletedRestrictionIsNotMatched(void)
+{
        sockaddr_u resaddr_target = create_sockaddr_u(AF_INET, 54321, "11.22.33.44");
 
        sockaddr_u resaddr_not_matching = create_sockaddr_u(AF_INET, 54321, "11.99.33.44");
@@ -186,8 +197,9 @@ test_DeletedRestrictionIsNotMatched(void) {
 }
 
 
-void
-test_RestrictUnflagWorks(void) {
+extern void test_RestrictUnflagWorks(void);
+void test_RestrictUnflagWorks(void)
+{
        sockaddr_u resaddr = create_sockaddr_u(AF_INET, 54321, "11.22.30.20");
        sockaddr_u resmask = create_sockaddr_u(AF_INET, 54321, "255.255.0.0");
 

diff --git a/tests/ntpd/rc_cmdlength.c b/tests/ntpd/rc_cmdlength.c
index dfe53167b67725da5bfad930ced2531efd290811..582070cfb47d2fb5a097e2b9dc56820ee33b1511 100644 (file)
--- a/tests/ntpd/rc_cmdlength.c
+++ b/tests/ntpd/rc_cmdlength.c
@@ -11,9 +11,9 @@
 
 #include "test-libntp.h"
 
-
-void
-test_EvaluateCommandLength(void){
+extern void test_EvaluateCommandLength(void);
+void test_EvaluateCommandLength(void)
+{
        size_t length, commandLength;
        const char *command1 = "Random Command";
        const char *command2 = "Random Command\t\t\n\t";
@@ -35,5 +35,4 @@ test_EvaluateCommandLength(void){
        length = strlen(command4);
        commandLength = remoteconfig_cmdlength(command4, command4+length);
        TEST_ASSERT_EQUAL(16, commandLength );
-
 }

diff --git a/tests/ntpd/run-leapsec.c b/tests/ntpd/run-leapsec.c
index 03b633e1ef25e2258eeac2f55b976be32179025e..30fffdeccd6d6802a4f26d7016d35a74771dda43 100644 (file)
--- a/tests/ntpd/run-leapsec.c
+++ b/tests/ntpd/run-leapsec.c
@@ -27,6 +27,7 @@
 #include "ntp_calendar.h"
 #include "ntp_stdlib.h"
 #include "ntp_leapsec.h"
+#include "lib_strbuf.h"
 #include "test-libntp.h"
 #include <string.h>
 
@@ -84,39 +85,39 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("leapsec.c");
-  RUN_TEST(test_ValidateGood, 351);
-  RUN_TEST(test_ValidateNoHash, 362);
-  RUN_TEST(test_ValidateBad, 373);
-  RUN_TEST(test_ValidateMalformed, 385);
-  RUN_TEST(test_ValidateMalformedShort, 397);
-  RUN_TEST(test_ValidateNoLeadZero, 409);
-  RUN_TEST(test_tableSelect, 426);
-  RUN_TEST(test_loadFileExpire, 466);
-  RUN_TEST(test_loadFileTTL, 487);
-  RUN_TEST(test_lsQueryPristineState, 522);
-  RUN_TEST(test_ls2009faraway, 538);
-  RUN_TEST(test_ls2009weekaway, 559);
-  RUN_TEST(test_ls2009houraway, 580);
-  RUN_TEST(test_ls2009secaway, 601);
-  RUN_TEST(test_ls2009onspot, 622);
-  RUN_TEST(test_ls2009nodata, 643);
-  RUN_TEST(test_ls2009limdata, 664);
-  RUN_TEST(test_qryJumpFarAhead, 689);
-  RUN_TEST(test_qryJumpAheadToTransition, 712);
-  RUN_TEST(test_qryJumpAheadOverTransition, 737);
-  RUN_TEST(test_addDynamic, 767);
-  RUN_TEST(test_taiEmptyTable, 961);
-  RUN_TEST(test_taiTableFixed, 974);
-  RUN_TEST(test_taiTableDynamic, 990);
-  RUN_TEST(test_taiTableDynamicDeadZone, 1020);
-  RUN_TEST(test_ls2009seqInsElectric, 1044);
-  RUN_TEST(test_ls2009seqInsDumb, 1091);
-  RUN_TEST(test_ls2009seqDelElectric, 1143);
-  RUN_TEST(test_ls2009seqDelDumb, 1190);
-  RUN_TEST(test_ls2012seqInsElectric, 1236);
-  RUN_TEST(test_ls2012seqInsDumb, 1283);
-  RUN_TEST(test_lsEmptyTableDumb, 1336);
-  RUN_TEST(test_lsEmptyTableElectric, 1365);
+  RUN_TEST(test_ValidateGood, 329);
+  RUN_TEST(test_ValidateNoHash, 339);
+  RUN_TEST(test_ValidateBad, 349);
+  RUN_TEST(test_ValidateMalformed, 359);
+  RUN_TEST(test_ValidateMalformedShort, 369);
+  RUN_TEST(test_ValidateNoLeadZero, 379);
+  RUN_TEST(test_tableSelect, 394);
+  RUN_TEST(test_loadFileExpire, 431);
+  RUN_TEST(test_loadFileTTL, 449);
+  RUN_TEST(test_lsQueryPristineState, 482);
+  RUN_TEST(test_ls2009faraway, 496);
+  RUN_TEST(test_ls2009weekaway, 515);
+  RUN_TEST(test_ls2009houraway, 534);
+  RUN_TEST(test_ls2009secaway, 553);
+  RUN_TEST(test_ls2009onspot, 572);
+  RUN_TEST(test_ls2009nodata, 591);
+  RUN_TEST(test_ls2009limdata, 610);
+  RUN_TEST(test_qryJumpFarAhead, 633);
+  RUN_TEST(test_qryJumpAheadToTransition, 656);
+  RUN_TEST(test_qryJumpAheadOverTransition, 679);
+  RUN_TEST(test_addDynamic, 706);
+  RUN_TEST(test_taiEmptyTable, 892);
+  RUN_TEST(test_taiTableFixed, 906);
+  RUN_TEST(test_taiTableDynamic, 920);
+  RUN_TEST(test_taiTableDynamicDeadZone, 948);
+  RUN_TEST(test_ls2009seqInsElectric, 970);
+  RUN_TEST(test_ls2009seqInsDumb, 1015);
+  RUN_TEST(test_ls2009seqDelElectric, 1064);
+  RUN_TEST(test_ls2009seqDelDumb, 1109);
+  RUN_TEST(test_ls2012seqInsElectric, 1153);
+  RUN_TEST(test_ls2012seqInsDumb, 1198);
+  RUN_TEST(test_lsEmptyTableDumb, 1249);
+  RUN_TEST(test_lsEmptyTableElectric, 1272);
 
   return (UnityEnd());
 }

diff --git a/tests/ntpd/run-ntp_prio_q.c b/tests/ntpd/run-ntp_prio_q.c
index 35af443de58e2dceb6c2d947f3949f89f3cf5e0c..10dab41c3eb4d97ed5be7e3598ee41d319ef7587 100644 (file)
--- a/tests/ntpd/run-ntp_prio_q.c
+++ b/tests/ntpd/run-ntp_prio_q.c
@@ -57,13 +57,13 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("ntp_prio_q.c");
-  RUN_TEST(test_AllocateDeallocateNode, 39);
+  RUN_TEST(test_AllocateDeallocateNode, 38);
   RUN_TEST(test_EmptyQueue, 46);
-  RUN_TEST(test_OneElementQueue, 60);
-  RUN_TEST(test_MultipleElementQueue, 88);
-  RUN_TEST(test_CustomOrderQueue, 126);
-  RUN_TEST(test_DestroyNonEmptyQueue, 183);
-  RUN_TEST(test_AppendQueues, 205);
+  RUN_TEST(test_OneElementQueue, 61);
+  RUN_TEST(test_MultipleElementQueue, 90);
+  RUN_TEST(test_CustomOrderQueue, 129);
+  RUN_TEST(test_DestroyNonEmptyQueue, 187);
+  RUN_TEST(test_AppendQueues, 211);
 
   return (UnityEnd());
 }

diff --git a/tests/ntpd/run-ntp_restrict.c b/tests/ntpd/run-ntp_restrict.c
index d88446207afe567a78f85fcb8a6c5284747b1fbf..b973fa180e6abfd4980d14bd477cb93f23dce7fd 100644 (file)
--- a/tests/ntpd/run-ntp_restrict.c
+++ b/tests/ntpd/run-ntp_restrict.c
@@ -55,14 +55,14 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("ntp_restrict.c");
-  RUN_TEST(test_RestrictionsAreEmptyAfterInit, 60);
-  RUN_TEST(test_ReturnsCorrectDefaultRestrictions, 86);
-  RUN_TEST(test_HackingDefaultRestriction, 97);
-  RUN_TEST(test_CantRemoveDefaultEntry, 120);
-  RUN_TEST(test_AddingNewRestriction, 131);
-  RUN_TEST(test_TheMostFittingRestrictionIsMatched, 144);
-  RUN_TEST(test_DeletedRestrictionIsNotMatched, 166);
-  RUN_TEST(test_RestrictUnflagWorks, 190);
+  RUN_TEST(test_RestrictionsAreEmptyAfterInit, 63);
+  RUN_TEST(test_ReturnsCorrectDefaultRestrictions, 90);
+  RUN_TEST(test_HackingDefaultRestriction, 102);
+  RUN_TEST(test_CantRemoveDefaultEntry, 126);
+  RUN_TEST(test_AddingNewRestriction, 138);
+  RUN_TEST(test_TheMostFittingRestrictionIsMatched, 152);
+  RUN_TEST(test_DeletedRestrictionIsNotMatched, 175);
+  RUN_TEST(test_RestrictUnflagWorks, 200);
 
   return (UnityEnd());
 }

diff --git a/tests/ntpd/run-rc_cmdlength.c b/tests/ntpd/run-rc_cmdlength.c
index 927a45e73a4ad7ba5718fcfaeecb25e3f8254fdd..6e332e593cd9441c2e3670c39d73e053088a4751 100644 (file)
--- a/tests/ntpd/run-rc_cmdlength.c
+++ b/tests/ntpd/run-rc_cmdlength.c
@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("rc_cmdlength.c");
-  RUN_TEST(test_EvaluateCommandLength, 16);
+  RUN_TEST(test_EvaluateCommandLength, 14);
 
   return (UnityEnd());
 }

diff --git a/tests/ntpd/run-t-ntp_scanner.c b/tests/ntpd/run-t-ntp_scanner.c
index 62d3ed3085d06434140eafc5da95655d598e84d3..2b250b0f76acf7672078c0e84e608b1c006df286 100644 (file)
--- a/tests/ntpd/run-t-ntp_scanner.c
+++ b/tests/ntpd/run-t-ntp_scanner.c
@@ -56,17 +56,17 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("t-ntp_scanner.c");
-  RUN_TEST(test_keywordIncorrectToken, 21);
-  RUN_TEST(test_keywordServerToken, 22);
-  RUN_TEST(test_DropUninitializedStack, 23);
-  RUN_TEST(test_IncorrectlyInitializeLexStack, 24);
-  RUN_TEST(test_InitializeLexStack, 25);
-  RUN_TEST(test_PopEmptyStack, 61);
-  RUN_TEST(test_IsInteger, 69);
-  RUN_TEST(test_IsUint, 87);
-  RUN_TEST(test_IsDouble, 99);
-  RUN_TEST(test_SpecialSymbols, 111);
-  RUN_TEST(test_EOC, 120);
+  RUN_TEST(test_keywordIncorrectToken, 8);
+  RUN_TEST(test_keywordServerToken, 16);
+  RUN_TEST(test_DropUninitializedStack, 24);
+  RUN_TEST(test_IncorrectlyInitializeLexStack, 30);
+  RUN_TEST(test_InitializeLexStack, 38);
+  RUN_TEST(test_PopEmptyStack, 49);
+  RUN_TEST(test_IsInteger, 57);
+  RUN_TEST(test_IsUint, 76);
+  RUN_TEST(test_IsDouble, 90);
+  RUN_TEST(test_SpecialSymbols, 104);
+  RUN_TEST(test_EOC, 115);
 
   return (UnityEnd());
 }

diff --git a/tests/ntpd/t-ntp_scanner.c b/tests/ntpd/t-ntp_scanner.c
index 862a2ee2bbae35fb82949fe688ee34ec3aee27a0..470449b06c2215d653071a9d924eb57c2b021e32 100644 (file)
--- a/tests/ntpd/t-ntp_scanner.c
+++ b/tests/ntpd/t-ntp_scanner.c
@@ -2,71 +2,61 @@
 
 #include "unity.h"
 
-//#include <stdio.h>
-//#include <ctype.h>
-//#include <stdlib.h>
-//#include <errno.h>
-//#include <string.h>
-
-//#include "ntpd.h"
-//#include "ntp_config.h"
-//#include "ntpsim.h"
-//#include "ntp_scanner.h"
-//#include "ntp_parser.h"
-
 #include "ntp_scanner.c"
 /* ntp_keyword.h declares finite state machine and token text */
-//#include "ntp_keyword.h"
-
-void test_keywordIncorrectToken(void);
-void test_keywordServerToken(void);
-void test_DropUninitializedStack(void);
-void test_IncorrectlyInitializeLexStack(void);
-void test_InitializeLexStack(void);
 
-
-void test_keywordIncorrectToken(void){
+extern void test_keywordIncorrectToken(void);
+void test_keywordIncorrectToken(void)
+{
        const char * temp = keyword(999);
        //printf("%s\n",temp);
        TEST_ASSERT_EQUAL_STRING("(keyword not found)",temp);
 }
 
-void test_keywordServerToken(void){
+extern void test_keywordServerToken(void);
+void test_keywordServerToken(void)
+{
        const char * temp = keyword(T_Server);
        //printf("%s",temp); //143 or 401 ?
        TEST_ASSERT_EQUAL_STRING("server",temp);
 }
 
-void test_DropUninitializedStack(void){
+extern void test_DropUninitializedStack(void);
+void test_DropUninitializedStack(void)
+{
        lex_drop_stack();
 }
 
-void test_IncorrectlyInitializeLexStack(void){
+extern void test_IncorrectlyInitializeLexStack(void);
+void test_IncorrectlyInitializeLexStack(void)
+{
 
        TEST_ASSERT_FALSE(lex_init_stack(NULL,NULL));
        lex_drop_stack();
 }
 
-void test_InitializeLexStack(void){
+extern void test_InitializeLexStack(void);
+void test_InitializeLexStack(void)
+{
        
        //Some sort of server is required for this to work.
-       sockaddr_u *    remote_addr;
        char origin[128] ={ "" } ;
        strcat(origin,"127.0.0.1");
-       //snprintf(origin, sizeof(origin), "remote config from %s", stoa(remote_addr));
        TEST_ASSERT_TRUE(lex_init_stack(origin,NULL)); //path, mode -> NULL is ok!
        lex_drop_stack();
 }
 
-void test_PopEmptyStack(void){
+extern void test_PopEmptyStack(void);
+void test_PopEmptyStack(void)
+{
        int temp = lex_pop_file();
 
        TEST_ASSERT_FALSE(temp);
 }
 
-
-
-void test_IsInteger(void){ //boolean
+extern void test_IsInteger(void);
+void test_IsInteger(void)
+{
        int temp = is_integer("123");
        TEST_ASSERT_TRUE(temp);
        temp = is_integer("-999");
@@ -81,10 +71,11 @@ void test_IsInteger(void){ //boolean
        TEST_ASSERT_TRUE(temp);
        temp = is_integer("2347483647"); //too big for signed int
        TEST_ASSERT_FALSE(temp);
-
 }
 
-void test_IsUint(void){
+extern void test_IsUint(void);
+void test_IsUint(void)
+{
        int temp;
        temp = is_u_int("-123");
        TEST_ASSERT_FALSE(temp);
@@ -96,7 +87,9 @@ void test_IsUint(void){
        TEST_ASSERT_TRUE(temp);         
 }
 
-void test_IsDouble(void){
+extern void test_IsDouble(void);
+void test_IsDouble(void)
+{
        int temp;       
        temp = is_double("0");
        TEST_ASSERT_TRUE(temp);
@@ -108,7 +101,9 @@ void test_IsDouble(void){
        TEST_ASSERT_TRUE(temp);
 }
 
-void test_SpecialSymbols(void){
+extern void test_SpecialSymbols(void);
+void test_SpecialSymbols(void)
+{
        int temp ;
        temp = is_special('a');
        TEST_ASSERT_FALSE(temp);
@@ -117,7 +112,9 @@ void test_SpecialSymbols(void){
 
 }
 
-void test_EOC(void){
+extern void test_EOC(void);
+void test_EOC(void)
+{
        int temp;
        if(old_config_style){
                temp = is_EOC('\n');
@@ -131,6 +128,5 @@ void test_EOC(void){
        TEST_ASSERT_FALSE(temp);
        temp = is_EOC('1');
        TEST_ASSERT_FALSE(temp);
-
 }