From: Juergen Perlinger <perlinger@ntp.org>
Date: Mon, 30 Oct 2017 08:46:03 +0000 (+0100)
Subject: Fix trivial warnings from 'make check'
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=add40aa9232bf2bb6fea82a296925d2a9a3110cb;p=thirdparty%2Fntp.git

Fix trivial warnings from 'make check'

bk: 59f6e6cbRNeYCmn0CBqtlXccTr5Qkg
---

diff --git a/ChangeLog b/ChangeLog
index e117bfcd1..399f09a58 100644
--- 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 36ecd39c8..34a6ed76e 100644
--- 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 4b27157a9..7741af82f 100644
--- 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 08d236e24..7b1a60a04 100644
--- 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 dfe53167b..582070cfb 100644
--- 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 03b633e1e..30fffdecc 100644
--- 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 35af443de..10dab41c3 100644
--- 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 d88446207..b973fa180 100644
--- 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 927a45e73..6e332e593 100644
--- 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 62d3ed308..2b250b0f7 100644
--- 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 862a2ee2b..470449b06 100644
--- 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);
-
 }