calendar.c:

  added function declarations + minor comment fixes

Many files:
  added declarations

  updated

run-buftvtots.c, run-calendar.c:
  update
lfptest.c:
  added #include
buftvtots.c:
  added function declarations
caljulian.c:
  added declarations
run-caljulian.c:
  updated

bk: 55b269ed8P0dbVBCAwoY9xQJBtS0Vg

diff --git a/tests/libntp/buftvtots.c b/tests/libntp/buftvtots.c
index 875766e63dbf4189365b6d456b9115889bd9adaf..9f759a6f47fa413eaabfc914a4a279c766e77a2a 100644 (file)
--- a/tests/libntp/buftvtots.c
+++ b/tests/libntp/buftvtots.c
@@ -11,6 +11,10 @@
 // Required for Solaris.
 #include <math.h>
 
+void test_ZeroBuffer(void);
+void test_IntegerAndFractionalBuffer(void);
+void test_IllegalMicroseconds(void);
+void test_AlwaysFalseOnWindows(void);
 
 
 void

diff --git a/tests/libntp/calendar.c b/tests/libntp/calendar.c
index 016e384e2d6249c378590021340098018dcd066a..80fcd2c377df18276aa5e56fce2abbfc53f1b5ba 100644 (file)
--- a/tests/libntp/calendar.c
+++ b/tests/libntp/calendar.c
@@ -8,19 +8,42 @@
 
 static int leapdays(int year);
 
-char * CalendarFromCalToString(const struct calendar cal); //&
-char * CalendarFromIsoToString(const struct isodate iso); //&
+char * CalendarFromCalToString(const struct calendar cal); 
+char * CalendarFromIsoToString(const struct isodate iso);
 
 // technically, booleans
-int IsEqualCal(const struct calendar expected, const struct calendar actual);  //&&
-int IsEqualIso(const struct isodate expected, const struct isodate actual); //&&
+int IsEqualCal(const struct calendar expected, const struct calendar actual);
+int IsEqualIso(const struct isodate expected, const struct isodate actual);
 
-char * DateFromCalToStringCal(const struct calendar cal); //&
-char * DateFromIsoToStringIso(const struct isodate iso); //&
+char * DateFromCalToStringCal(const struct calendar cal);
+char * DateFromIsoToStringIso(const struct isodate iso);
 
 // technically, booleans
-int sEqualDateCal(const struct calendar expected, const struct calendar actual); //&&
-int IsEqualDateIso(const struct isodate expected, const struct isodate actual); //&&
+int sEqualDateCal(const struct calendar expected, const struct calendar actual);
+int IsEqualDateIso(const struct isodate expected, const struct isodate actual);
+
+
+int isGT(int first, int second);
+int leapdays(int year);
+char * CalendarFromCalToString(const struct calendar cal);
+char * CalendarFromIsoToString(const struct isodate iso); 
+int IsEqualCal(const struct calendar expected, const struct calendar actual);
+int IsEqualIso(const struct isodate expected, const struct isodate actual);
+char * DateFromCalToString(const struct calendar cal);
+char * DateFromIsoToString(const struct isodate iso);
+int IsEqualDateCal(const struct calendar expected, const struct calendar actual);
+int IsEqualDateIso(const struct isodate expected, const struct isodate actual);
+void test_DaySplitMerge(void);
+void test_SplitYearDays1(void);
+void test_SplitYearDays2(void);
+void test_RataDie1(void);
+void test_LeapYears1(void);
+void test_LeapYears2(void);
+void test_RoundTripDate(void);
+void test_RoundTripYearStart(void);
+void test_RoundTripMonthStart(void);
+void test_RoundTripWeekStart(void);
+void test_RoundTripDayStart(void);
 
 
 
@@ -29,7 +52,8 @@ int IsEqualDateIso(const struct isodate expected, const struct isodate actual);
 // ---------------------------------------------------------------------
 
 int
-isGT(int first, int second){
+isGT(int first, int second)
+{
        if(first > second) {    
                return TRUE;
        } else {
@@ -50,7 +74,7 @@ leapdays(int year)
 }
 
 char *
-CalendarFromCalToString(const struct calendar cal) { //&
+CalendarFromCalToString(const struct calendar cal) {
        char * str = malloc (sizeof (char) * 100);
        
        char buffer[100] ="";
@@ -79,7 +103,7 @@ CalendarFromCalToString(const struct calendar cal) { //&
 }
 
 char *
-CalendarFromIsoToString(const struct isodate iso) { //&
+CalendarFromIsoToString(const struct isodate iso) {
 
        char * str = malloc (sizeof (char) * 100);
        
@@ -105,7 +129,7 @@ CalendarFromIsoToString(const struct isodate iso) { //&
 }
 
 int
-IsEqualCal(const struct calendar expected, const struct calendar actual) { //&&
+IsEqualCal(const struct calendar expected, const struct calendar actual) {
        if (expected.year == actual.year &&
            (!expected.yearday || expected.yearday == actual.yearday) &&
            expected.month == actual.month &&
@@ -121,7 +145,7 @@ IsEqualCal(const struct calendar expected, const struct calendar actual) { //&&
 }
 
 int
-IsEqualIso(const struct isodate expected, const struct isodate actual) { //&&
+IsEqualIso(const struct isodate expected, const struct isodate actual) {
        if (expected.year == actual.year &&
            expected.week == actual.week &&
            expected.weekday == actual.weekday &&
@@ -136,7 +160,7 @@ IsEqualIso(const struct isodate expected, const struct isodate actual) { //&&
 }
 
 char *
-DateFromCalToString(const struct calendar cal) { //&
+DateFromCalToString(const struct calendar cal) {
 
        char * str = malloc (sizeof (char) * 100);
        
@@ -158,7 +182,7 @@ DateFromCalToString(const struct calendar cal) { //&
 }
 
 char *
-DateFromIsoToString(const struct isodate iso) { //&
+DateFromIsoToString(const struct isodate iso) {
 
        char * str = malloc (sizeof (char) * 100);
        
@@ -177,7 +201,7 @@ DateFromIsoToString(const struct isodate iso) { //&
 
 // boolean 
 int
-IsEqualDateCal(const struct calendar expected, const struct calendar actual) { //&&
+IsEqualDateCal(const struct calendar expected, const struct calendar actual) {
        if (expected.year == actual.year &&
            (!expected.yearday || expected.yearday == actual.yearday) &&
            expected.month == actual.month &&
@@ -191,7 +215,7 @@ IsEqualDateCal(const struct calendar expected, const struct calendar actual) { /
 
 // boolean
 int
-IsEqualDateIso(const struct isodate expected, const struct isodate actual) { //&&
+IsEqualDateIso(const struct isodate expected, const struct isodate actual) {
        if (expected.year == actual.year &&
            expected.week == actual.week &&
            expected.weekday == actual.weekday) {

diff --git a/tests/libntp/caljulian.c b/tests/libntp/caljulian.c
index c2f7b175521864b48821265f82bc1aef7f047213..4221694547b4ae0439f77486003c47d2ceac60e4 100644 (file)
--- a/tests/libntp/caljulian.c
+++ b/tests/libntp/caljulian.c
@@ -9,6 +9,16 @@
 #include <string.h>
 
 
+char * CalendarToString(const struct calendar cal);
+int IsEqual(const struct calendar expected, const struct calendar actual);
+void setUp(void);
+void tearDown(void);
+void test_RegularTime(void);
+void test_LeapYear(void);
+void test_uLongBoundary(void);
+void test_uLongWrapped(void);
+
+
 char *
 CalendarToString(const struct calendar cal) {
        char * str = malloc (sizeof (char) * 100);

diff --git a/tests/libntp/caltontp.c b/tests/libntp/caltontp.c
index bdbfbfc7a36c9cf57a9d45968b6cd49289c62cd5..34173d27eb9c33eb6086c584d3a0d5e48cd9ec85 100644 (file)
--- a/tests/libntp/caltontp.c
+++ b/tests/libntp/caltontp.c
@@ -2,6 +2,11 @@
 #include "ntp_calendar.h"
 #include "unity.h"
 
+void test_DateGivenMonthDay(void);
+void test_DateGivenYearDay(void);
+void test_DateLeapYear(void);
+void test_WraparoundDateIn2036(void);
+
 void
 test_DateGivenMonthDay(void) {
        // 2010-06-24 12:50:00

diff --git a/tests/libntp/calyearstart.c b/tests/libntp/calyearstart.c
index 137d41530ba07edcbe36becc90dde2174548694b..271ea12b6892f873e41652e5693d66606bf685ac 100644 (file)
--- a/tests/libntp/calyearstart.c
+++ b/tests/libntp/calyearstart.c
@@ -6,6 +6,11 @@
 
 #include "test-libntp.h"
 
+void setUp(void);
+void tearDown(void);
+void test_NoWrapInDateRange(void);
+void test_NoWrapInDateRangeLeapYear(void);
+void test_WrapInDateRange(void);
 
 void setUp(void)
 {

diff --git a/tests/libntp/clocktime.c b/tests/libntp/clocktime.c
index f1d0726671591e4d34c1f886a1a22fdafdaf684a..35b5dc7104c5413a7b4591b97043b9601cfa78ea 100644 (file)
--- a/tests/libntp/clocktime.c
+++ b/tests/libntp/clocktime.c
@@ -6,6 +6,17 @@
 #include "unity.h"
 #include "test-libntp.h"
 
+void setUp(void);
+void tearDown(void);
+void test_CurrentYear(void);
+void test_CurrentYearFuzz(void);
+void test_TimeZoneOffset(void);
+void test_WrongYearStart(void);
+void test_PreviousYear(void);
+void test_NextYear(void);
+void test_NoReasonableConversion(void);
+void test_AlwaysInLimit(void);
+
 
 // ---------------------------------------------------------------------
 // test fixture

diff --git a/tests/libntp/decodenetnum.c b/tests/libntp/decodenetnum.c
index 22c1507a30e092053233b9eab6002f378e0b43ec..77491b8b312f105a5b4849c83230fe37cc098d8d 100644 (file)
--- a/tests/libntp/decodenetnum.c
+++ b/tests/libntp/decodenetnum.c
@@ -4,6 +4,13 @@
 
 #include "unity.h"
 
+extern void test_IPv4AddressOnly(void);
+extern void test_IPv4AddressWithPort(void);
+extern void test_IPv6AddressOnly(void);
+extern void test_IPv6AddressWithPort(void);
+extern void test_IllegalAddress(void);
+extern void test_IllegalCharInPort(void);
+
 
 void
 test_IPv4AddressOnly(void) {

diff --git a/tests/libntp/hextoint.c b/tests/libntp/hextoint.c
index e9f0d398fee8e431aba57d7991d8185d0dc4caa6..443a1b8310d15e80acd1301f40fec7f702eb8c12 100644 (file)
--- a/tests/libntp/hextoint.c
+++ b/tests/libntp/hextoint.c
@@ -6,6 +6,12 @@
 
 #include "unity.h"
 
+void test_SingleDigit(void);
+void test_MultipleDigits(void);
+void test_MaxUnsigned(void);
+void test_Overflow(void);
+void test_IllegalChar(void);
+
 
 void test_SingleDigit(void) {
         const char *str = "a"; // 10 decimal

diff --git a/tests/libntp/hextolfp.c b/tests/libntp/hextolfp.c
index 228242f6fe9b38ca660969b0ece7b6cf807f2466..9d7fb2058aaff3681cd6c21e1ec17469c5a3e7bf 100644 (file)
--- a/tests/libntp/hextolfp.c
+++ b/tests/libntp/hextolfp.c
@@ -6,6 +6,13 @@
 #include "unity.h"
 #include "lfptest.h"
 
+void test_PositiveInteger(void);
+void test_NegativeInteger(void);
+void test_PositiveFraction(void);
+void test_NegativeFraction(void);
+void test_IllegalNumberOfInteger(void);
+void test_IllegalChar(void);
+
 
 void
 test_PositiveInteger(void) {

diff --git a/tests/libntp/humandate.c b/tests/libntp/humandate.c
index 561d28b9bbb61a779324561dc9daa92dec78e1be..3a28f59dc4b0ec8846c7a8a9b2e954650217f6b4 100644 (file)
--- a/tests/libntp/humandate.c
+++ b/tests/libntp/humandate.c
@@ -5,6 +5,10 @@
 
 #include "unity.h"
 
+void test_RegularTime(void);
+void test_CurrentTime(void);
+
+
 void
 test_RegularTime(void)
 {

diff --git a/tests/libntp/lfpfunc.c b/tests/libntp/lfpfunc.c
index 1ddcd8ab114fc2c377fa9aeb67cf598ae5c7d751..f38e3d3cc270a0096b1928416d80bbfc62ec2b55 100644 (file)
--- a/tests/libntp/lfpfunc.c
+++ b/tests/libntp/lfpfunc.c
@@ -18,6 +18,19 @@
     TEST_ASSERT_EQUAL_UINT_MESSAGE(a.l_uf, b.l_uf, "Field l_uf");      \
 }
 
+
+void test_AdditionLR(void);
+void test_AdditionRL(void);
+void test_SubtractionLR(void);
+void test_SubtractionRL(void);
+void test_Negation(void);
+void test_Absolute(void);
+void test_FDF_RoundTrip(void);
+void test_SignedRelOps(void);
+void test_UnsignedRelOps(void);
+
+
+
 typedef struct  {
        uint32_t h, l;
 } lfp_hl;

diff --git a/tests/libntp/lfptest.c b/tests/libntp/lfptest.c
index b9546b219e197d1ccdd16e8dce7b33fdb54b83c8..7b4dccf99f1f011723a5c29995a1ecbe152969fb 100644 (file)
--- a/tests/libntp/lfptest.c
+++ b/tests/libntp/lfptest.c
@@ -1,5 +1,6 @@
 #include "config.h"
 #include "ntp_fp.h"
+#include "lfptest.h"
 
 int IsEqual(const l_fp expected, const l_fp actual) {
        if (L_ISEQU(&expected, &actual)) {

diff --git a/tests/libntp/lfptostr.c b/tests/libntp/lfptostr.c
index 338e20a2518a5a9d79ee394975603f26dee6a9d0..267c3021cf7e9860dbbb0f9a1ea4afd5532673a6 100644 (file)
--- a/tests/libntp/lfptostr.c
+++ b/tests/libntp/lfptostr.c
@@ -19,6 +19,21 @@ static const int THREE_FOURTH = -1073741824;
 static const int HALF_PROMILLE_UP = 2147484; // slightly more than 0.0005
 static const int HALF_PROMILLE_DOWN = 2147483; // slightly less than 0.0005
 
+
+void test_PositiveInteger(void);
+void test_NegativeInteger(void);
+void test_PositiveIntegerWithFraction(void);
+void test_NegativeIntegerWithFraction(void);
+void test_RoundingDownToInteger(void);
+void test_RoundingMiddleToInteger(void);
+void test_RoundingUpToInteger(void);
+void test_SingleDecimal(void);
+void test_MillisecondsRoundingUp(void);
+void test_MillisecondsRoundingDown(void);
+void test_UnsignedInteger(void);
+
+
+
 void
 test_PositiveInteger(void) {
        l_fp test = {200, 0}; // exact 200.0000000000

diff --git a/tests/libntp/modetoa.c b/tests/libntp/modetoa.c
index 5ad3f7bf7bb4ab28518febb9d40ee14b03584621..267b44e010a7a23002354f72593353d1ccfc3a7c 100644 (file)
--- a/tests/libntp/modetoa.c
+++ b/tests/libntp/modetoa.c
@@ -4,6 +4,9 @@
 
 #include "unity.h"
 
+void test_KnownMode(void);
+void test_UnknownMode(void);
+
 
 void
 test_KnownMode(void) {

diff --git a/tests/libntp/msyslog.c b/tests/libntp/msyslog.c
index 1c94bb3fea901a5c7fe69a238bfb869a04d3aef5..dec8d859269822ede1df82d3f9be0ff2bb0228dc 100644 (file)
--- a/tests/libntp/msyslog.c
+++ b/tests/libntp/msyslog.c
@@ -10,6 +10,16 @@ void format_errmsg(char *, size_t, const char *, int);
 #endif
 
 
+void test_msnprintf(void);
+void test_msnprintfLiteralPercentm(void);
+void test_msnprintfBackslashLiteralPercentm(void);
+void test_msnprintfBackslashPercent(void);
+void test_msnprintfHangingPercent(void);
+void test_format_errmsgHangingPercent(void);
+void test_msnprintfNullTarget(void);
+void test_msnprintfTruncate(void);
+
+
 void
 test_msnprintf(void) {
 #define FMT_PREFIX "msyslog.cpp ENOENT: "

diff --git a/tests/libntp/run-buftvtots.c b/tests/libntp/run-buftvtots.c
index dbf22a677da8d458b08b132c9bd7b9e816cb0e08..b0b06f0ac8872be0b8775c7b7fcf3787f2e67f31 100644 (file)
--- a/tests/libntp/run-buftvtots.c
+++ b/tests/libntp/run-buftvtots.c
@@ -22,12 +22,12 @@
 #include "unity.h"
 #include <setjmp.h>
 #include <stdio.h>
-//#include "config.h"
-//#include "ntp_types.h"
-//#include "ntp_stdlib.h"
-//#include "lfptest.h"
-//#include "ntp_unixtime.h"
-//#include <math.h>
+#include "config.h"
+#include "ntp_types.h"
+#include "ntp_stdlib.h"
+#include "lfptest.h"
+#include "ntp_unixtime.h"
+#include <math.h>
 
 //=======External Functions This Runner Calls=====
 extern void setUp(void);
@@ -54,10 +54,10 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("buftvtots.c");
-  RUN_TEST(test_ZeroBuffer, 17);
-  RUN_TEST(test_IntegerAndFractionalBuffer, 32);
-  RUN_TEST(test_IllegalMicroseconds, 55);
-  RUN_TEST(test_AlwaysFalseOnWindows, 69);
+  RUN_TEST(test_ZeroBuffer, 14);
+  RUN_TEST(test_IntegerAndFractionalBuffer, 15);
+  RUN_TEST(test_IllegalMicroseconds, 16);
+  RUN_TEST(test_AlwaysFalseOnWindows, 17);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-calendar.c b/tests/libntp/run-calendar.c
index 5acf249d2dc65319a1779a8fd53fcc4c9d167538..743eed4d5fa0e1edf1ffedb4fc6b72608192d005 100644 (file)
--- a/tests/libntp/run-calendar.c
+++ b/tests/libntp/run-calendar.c
@@ -59,17 +59,17 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("calendar.c");
-  RUN_TEST(test_DaySplitMerge, 228);
-  RUN_TEST(test_SplitYearDays1, 258);
-  RUN_TEST(test_SplitYearDays2, 273);
-  RUN_TEST(test_RataDie1, 289);
-  RUN_TEST(test_LeapYears1, 300);
-  RUN_TEST(test_LeapYears2, 316);
-  RUN_TEST(test_RoundTripDate, 335);
-  RUN_TEST(test_RoundTripYearStart, 365);
-  RUN_TEST(test_RoundTripMonthStart, 382);
-  RUN_TEST(test_RoundTripWeekStart, 399);
-  RUN_TEST(test_RoundTripDayStart, 416);
+  RUN_TEST(test_DaySplitMerge, 36);
+  RUN_TEST(test_SplitYearDays1, 37);
+  RUN_TEST(test_SplitYearDays2, 38);
+  RUN_TEST(test_RataDie1, 39);
+  RUN_TEST(test_LeapYears1, 40);
+  RUN_TEST(test_LeapYears2, 41);
+  RUN_TEST(test_RoundTripDate, 42);
+  RUN_TEST(test_RoundTripYearStart, 43);
+  RUN_TEST(test_RoundTripMonthStart, 44);
+  RUN_TEST(test_RoundTripWeekStart, 45);
+  RUN_TEST(test_RoundTripDayStart, 46);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-caljulian.c b/tests/libntp/run-caljulian.c
index 723322a5a75ac2cb888aa5e4d1b00fafd780fc12..c1e530ed1625171d0430085e1fb3943675924497 100644 (file)
--- a/tests/libntp/run-caljulian.c
+++ b/tests/libntp/run-caljulian.c
@@ -53,10 +53,10 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("caljulian.c");
-  RUN_TEST(test_RegularTime, 73);
-  RUN_TEST(test_LeapYear, 85);
-  RUN_TEST(test_uLongBoundary, 97);
-  RUN_TEST(test_uLongWrapped, 109);
+  RUN_TEST(test_RegularTime, 16);
+  RUN_TEST(test_LeapYear, 17);
+  RUN_TEST(test_uLongBoundary, 18);
+  RUN_TEST(test_uLongWrapped, 19);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-caltontp.c b/tests/libntp/run-caltontp.c
index aa9f9b5d79556bf4be184b26c62dc747cae258f6..29ce755a949221298b10e2aeaa608503d238327d 100644 (file)
--- a/tests/libntp/run-caltontp.c
+++ b/tests/libntp/run-caltontp.c
@@ -50,10 +50,10 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("caltontp.c");
-  RUN_TEST(test_DateGivenMonthDay, 6);
-  RUN_TEST(test_DateGivenYearDay, 16);
-  RUN_TEST(test_DateLeapYear, 27);
-  RUN_TEST(test_WraparoundDateIn2036, 40);
+  RUN_TEST(test_DateGivenMonthDay, 5);
+  RUN_TEST(test_DateGivenYearDay, 6);
+  RUN_TEST(test_DateLeapYear, 7);
+  RUN_TEST(test_WraparoundDateIn2036, 8);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-calyearstart.c b/tests/libntp/run-calyearstart.c
index b81ab35e4d88b28a2d594a0c38d7a366a8b5ab7f..448f13ffdd8a6792d7693f4a3d2b095342eb390e 100644 (file)
--- a/tests/libntp/run-calyearstart.c
+++ b/tests/libntp/run-calyearstart.c
@@ -51,9 +51,9 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("calyearstart.c");
-  RUN_TEST(test_NoWrapInDateRange, 22);
-  RUN_TEST(test_NoWrapInDateRangeLeapYear, 30);
-  RUN_TEST(test_WrapInDateRange, 38);
+  RUN_TEST(test_NoWrapInDateRange, 11);
+  RUN_TEST(test_NoWrapInDateRangeLeapYear, 12);
+  RUN_TEST(test_WrapInDateRange, 13);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-clocktime.c b/tests/libntp/run-clocktime.c
index 956dc65c589d9d5eaacef692c0d76923a562752a..64a094e3e13147c8df124695cb20f22f02c52baa 100644 (file)
--- a/tests/libntp/run-clocktime.c
+++ b/tests/libntp/run-clocktime.c
@@ -56,14 +56,14 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("clocktime.c");
-  RUN_TEST(test_CurrentYear, 35);
-  RUN_TEST(test_CurrentYearFuzz, 51);
-  RUN_TEST(test_TimeZoneOffset, 74);
-  RUN_TEST(test_WrongYearStart, 95);
-  RUN_TEST(test_PreviousYear, 115);
-  RUN_TEST(test_NextYear, 135);
-  RUN_TEST(test_NoReasonableConversion, 154);
-  RUN_TEST(test_AlwaysInLimit, 177);
+  RUN_TEST(test_CurrentYear, 11);
+  RUN_TEST(test_CurrentYearFuzz, 12);
+  RUN_TEST(test_TimeZoneOffset, 13);
+  RUN_TEST(test_WrongYearStart, 14);
+  RUN_TEST(test_PreviousYear, 15);
+  RUN_TEST(test_NextYear, 16);
+  RUN_TEST(test_NoReasonableConversion, 17);
+  RUN_TEST(test_AlwaysInLimit, 18);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-decodenetnum.c b/tests/libntp/run-decodenetnum.c
index d9d80e7e8d4a5965bb391e74f9e55e6f988a8a2f..ed7208ee133f73596443369da5202da4b844f275 100644 (file)
--- a/tests/libntp/run-decodenetnum.c
+++ b/tests/libntp/run-decodenetnum.c
@@ -53,12 +53,12 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("decodenetnum.c");
-  RUN_TEST(test_IPv4AddressOnly, 9);
-  RUN_TEST(test_IPv4AddressWithPort, 23);
-  RUN_TEST(test_IPv6AddressOnly, 37);
-  RUN_TEST(test_IPv6AddressWithPort, 58);
-  RUN_TEST(test_IllegalAddress, 79);
-  RUN_TEST(test_IllegalCharInPort, 87);
+  RUN_TEST(test_IPv4AddressOnly, 7);
+  RUN_TEST(test_IPv4AddressWithPort, 8);
+  RUN_TEST(test_IPv6AddressOnly, 9);
+  RUN_TEST(test_IPv6AddressWithPort, 10);
+  RUN_TEST(test_IllegalAddress, 11);
+  RUN_TEST(test_IllegalCharInPort, 12);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-hextoint.c b/tests/libntp/run-hextoint.c
index 1ffb062ebf73ff56ba33230c2857a98c2cdd466c..f21b85be4b10702e5a4decc3ef6fc00d8e0111ab 100644 (file)
--- a/tests/libntp/run-hextoint.c
+++ b/tests/libntp/run-hextoint.c
@@ -53,11 +53,11 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("hextoint.c");
-  RUN_TEST(test_SingleDigit, 10);
-  RUN_TEST(test_MultipleDigits, 18);
-  RUN_TEST(test_MaxUnsigned, 26);
-  RUN_TEST(test_Overflow, 34);
-  RUN_TEST(test_IllegalChar, 41);
+  RUN_TEST(test_SingleDigit, 9);
+  RUN_TEST(test_MultipleDigits, 10);
+  RUN_TEST(test_MaxUnsigned, 11);
+  RUN_TEST(test_Overflow, 12);
+  RUN_TEST(test_IllegalChar, 13);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-hextolfp.c b/tests/libntp/run-hextolfp.c
index c11992b5eada4c9dd52d1ce7f62d8847fb16efee..c6f6535ef4ac71b0094a125ccc40c2d0ff3cbdb8 100644 (file)
--- a/tests/libntp/run-hextolfp.c
+++ b/tests/libntp/run-hextolfp.c
@@ -54,12 +54,12 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("hextolfp.c");
-  RUN_TEST(test_PositiveInteger, 11);
-  RUN_TEST(test_NegativeInteger, 22);
-  RUN_TEST(test_PositiveFraction, 33);
-  RUN_TEST(test_NegativeFraction, 44);
-  RUN_TEST(test_IllegalNumberOfInteger, 55);
-  RUN_TEST(test_IllegalChar, 63);
+  RUN_TEST(test_PositiveInteger, 9);
+  RUN_TEST(test_NegativeInteger, 10);
+  RUN_TEST(test_PositiveFraction, 11);
+  RUN_TEST(test_NegativeFraction, 12);
+  RUN_TEST(test_IllegalNumberOfInteger, 13);
+  RUN_TEST(test_IllegalChar, 14);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-humandate.c b/tests/libntp/run-humandate.c
index acb1e5223cb6b3bb5cababcc5542f32758dedeaa..de52ed2e54b2ef26b5ab518a5837f8aeaf1de9dc 100644 (file)
--- a/tests/libntp/run-humandate.c
+++ b/tests/libntp/run-humandate.c
@@ -49,8 +49,8 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("humandate.c");
-  RUN_TEST(test_RegularTime, 9);
-  RUN_TEST(test_CurrentTime, 24);
+  RUN_TEST(test_RegularTime, 8);
+  RUN_TEST(test_CurrentTime, 9);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-lfpfunc.c b/tests/libntp/run-lfpfunc.c
index d01c2708e8d0b6bfe44cb2aac89f00e8da946b49..a7b6a43b52729d634c67e4abd7720288daf21be2 100644 (file)
--- a/tests/libntp/run-lfpfunc.c
+++ b/tests/libntp/run-lfpfunc.c
@@ -58,15 +58,15 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("lfpfunc.c");
-  RUN_TEST(test_AdditionLR, 251);
-  RUN_TEST(test_AdditionRL, 265);
-  RUN_TEST(test_SubtractionLR, 283);
-  RUN_TEST(test_SubtractionRL, 296);
-  RUN_TEST(test_Negation, 313);
-  RUN_TEST(test_Absolute, 333);
-  RUN_TEST(test_FDF_RoundTrip, 366);
-  RUN_TEST(test_SignedRelOps, 393);
-  RUN_TEST(test_UnsignedRelOps, 433);
+  RUN_TEST(test_AdditionLR, 22);
+  RUN_TEST(test_AdditionRL, 23);
+  RUN_TEST(test_SubtractionLR, 24);
+  RUN_TEST(test_SubtractionRL, 25);
+  RUN_TEST(test_Negation, 26);
+  RUN_TEST(test_Absolute, 27);
+  RUN_TEST(test_FDF_RoundTrip, 28);
+  RUN_TEST(test_SignedRelOps, 29);
+  RUN_TEST(test_UnsignedRelOps, 30);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-lfptostr.c b/tests/libntp/run-lfptostr.c
index 20dc878aa3c660ed22d920439af067f857785593..feb402224fbb7032d2daf4851952f7b0a727c19c 100644 (file)
--- a/tests/libntp/run-lfptostr.c
+++ b/tests/libntp/run-lfptostr.c
@@ -59,16 +59,16 @@ int main(int argc, char *argv[])
   progname = argv[0];
   UnityBegin("lfptostr.c");
   RUN_TEST(test_PositiveInteger, 23);
-  RUN_TEST(test_NegativeInteger, 31);
-  RUN_TEST(test_PositiveIntegerWithFraction, 39);
-  RUN_TEST(test_NegativeIntegerWithFraction, 47);
-  RUN_TEST(test_RoundingDownToInteger, 55);
-  RUN_TEST(test_RoundingMiddleToInteger, 63);
-  RUN_TEST(test_RoundingUpToInteger, 71);
-  RUN_TEST(test_SingleDecimal, 79);
-  RUN_TEST(test_MillisecondsRoundingUp, 87);
-  RUN_TEST(test_MillisecondsRoundingDown, 97);
-  RUN_TEST(test_UnsignedInteger, 106);
+  RUN_TEST(test_NegativeInteger, 24);
+  RUN_TEST(test_PositiveIntegerWithFraction, 25);
+  RUN_TEST(test_NegativeIntegerWithFraction, 26);
+  RUN_TEST(test_RoundingDownToInteger, 27);
+  RUN_TEST(test_RoundingMiddleToInteger, 28);
+  RUN_TEST(test_RoundingUpToInteger, 29);
+  RUN_TEST(test_SingleDecimal, 30);
+  RUN_TEST(test_MillisecondsRoundingUp, 31);
+  RUN_TEST(test_MillisecondsRoundingDown, 32);
+  RUN_TEST(test_UnsignedInteger, 33);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-modetoa.c b/tests/libntp/run-modetoa.c
index f43d863338c73e6e98db955d5b1b95c805597ad4..c9025c58a4a809a4675ef2710a66a2cae575ab32 100644 (file)
--- a/tests/libntp/run-modetoa.c
+++ b/tests/libntp/run-modetoa.c
@@ -48,8 +48,8 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("modetoa.c");
-  RUN_TEST(test_KnownMode, 9);
-  RUN_TEST(test_UnknownMode, 16);
+  RUN_TEST(test_KnownMode, 7);
+  RUN_TEST(test_UnknownMode, 8);
 
   return (UnityEnd());
 }

diff --git a/tests/libntp/run-msyslog.c b/tests/libntp/run-msyslog.c
index 6f117bb03aa59f20dc6d10dc2b6660b35c1c87e0..d53d6b278561ad8c8ef75b8f6eec2f1fcd065bcf 100644 (file)
--- a/tests/libntp/run-msyslog.c
+++ b/tests/libntp/run-msyslog.c
@@ -54,14 +54,14 @@ int main(int argc, char *argv[])
 {
   progname = argv[0];
   UnityBegin("msyslog.c");
-  RUN_TEST(test_msnprintf, 14);
-  RUN_TEST(test_msnprintfLiteralPercentm, 31);
-  RUN_TEST(test_msnprintfBackslashLiteralPercentm, 47);
-  RUN_TEST(test_msnprintfBackslashPercent, 62);
-  RUN_TEST(test_msnprintfHangingPercent, 78);
-  RUN_TEST(test_format_errmsgHangingPercent, 96);
-  RUN_TEST(test_msnprintfNullTarget, 112);
-  RUN_TEST(test_msnprintfTruncate, 124);
+  RUN_TEST(test_msnprintf, 13);
+  RUN_TEST(test_msnprintfLiteralPercentm, 14);
+  RUN_TEST(test_msnprintfBackslashLiteralPercentm, 15);
+  RUN_TEST(test_msnprintfBackslashPercent, 16);
+  RUN_TEST(test_msnprintfHangingPercent, 17);
+  RUN_TEST(test_format_errmsgHangingPercent, 18);
+  RUN_TEST(test_msnprintfNullTarget, 19);
+  RUN_TEST(test_msnprintfTruncate, 20);
 
   return (UnityEnd());
 }