|
|
@@ -0,0 +1,1207 @@
|
|
|
+/*
|
|
|
+ * Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
|
|
|
+ * This program is free software. It comes without any warranty, to the extent
|
|
|
+ * permitted by applicable law. You can redistribute it and/or modify it under
|
|
|
+ * the terms of the Do What The Fuck You Want To Public License, Version 2, as
|
|
|
+ * published by Sam Hocevar. See the COPYING file for more details.
|
|
|
+ */
|
|
|
+
|
|
|
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
|
|
|
+#pragma GCC diagnostic ignored "-Wtype-limits"
|
|
|
+
|
|
|
+#include <stdlib.h>
|
|
|
+#include <string.h>
|
|
|
+#include <check.h>
|
|
|
+
|
|
|
+#include "minmea.h"
|
|
|
+
|
|
|
+static const char *valid_sentences_nochecksum[] = {
|
|
|
+ "$GPTXT,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
|
|
|
+ "$GPTXT,xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
|
|
|
+ "xxxxxxxxxxxxxxxxxxxxxxxxxxx",
|
|
|
+ "$GPTXT,hello\n",
|
|
|
+ "$GPTXT,hello\r",
|
|
|
+ "$GPTXT,hello\r\n",
|
|
|
+ "$GPTXT,hello\r\n\r\n",
|
|
|
+ "$GPTXT,hello\n\r\r\n",
|
|
|
+ NULL,
|
|
|
+};
|
|
|
+
|
|
|
+static const char *valid_sentences_checksum[] = {
|
|
|
+ "$GPTXT,01,01,02,ANTSTATUS=INIT*25",
|
|
|
+ "$GPRMC,,V,,,,,,,,,,N*53",
|
|
|
+ "$GPVTG,,,,,,,,,N*30",
|
|
|
+ "$GPGGA,,,,,,0,00,99.99,,,,,,*48",
|
|
|
+ "$GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99.99*30",
|
|
|
+ "$GPGLL,,,,,,V,N*64",
|
|
|
+ "$GPXTE,A,A,0.67,L,N*6F",
|
|
|
+ "$GPXTE,A,A,0.67,L,N*6f",
|
|
|
+ "$GPGGA,123204.00,5106.94086,N,01701.51680,E,1,06,3.86,127.9,M,40.5,M,,*51",
|
|
|
+ "$GPGSA,A,3,02,08,09,05,04,26,,,,,,,4.92,3.86,3.05*00",
|
|
|
+ "$GPGSV,4,1,13,02,28,259,33,04,12,212,27,05,34,305,30,07,79,138,*7F",
|
|
|
+ "$GPGSV,4,2,13,08,51,203,30,09,45,215,28,10,69,197,19,13,47,081,*76",
|
|
|
+ "$GPGSV,4,3,13,16,20,040,17,26,08,271,30,28,01,168,18,33,24,219,27*74",
|
|
|
+ "$GPGSV,4,4,13,39,31,170,27*40",
|
|
|
+ "$GPGLL,5106.94086,N,01701.51680,E,123204.00,A,A*63",
|
|
|
+ "$GPRMC,123205.00,A,5106.94085,N,01701.51689,E,0.016,,280214,,,A*7B",
|
|
|
+ "$GPVTG,,T,,M,0.016,N,0.030,K,A*27",
|
|
|
+ "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58",
|
|
|
+ "$GPZDA,160012.71,11,03,2004,-1,00*7D",
|
|
|
+ "$GNGBS,170556.00,3.0,2.9,8.3,,,,*5C",
|
|
|
+ NULL,
|
|
|
+};
|
|
|
+
|
|
|
+static const char *invalid_sentences[] = {
|
|
|
+ "$GPTXT,01,01,02,ANTSTATUS=INIT*26",
|
|
|
+ "$GPRMC,,V,,,,,,,,,,N*532",
|
|
|
+ "$GPVTG,,,,\xff,,,,,N*30",
|
|
|
+ "$$GPGGA,,,,,,0,00,99.99,,,,,,*48",
|
|
|
+ "GPGSA,A,1,,,,,,,,,,,,,99.99,99.99,99.99*30",
|
|
|
+ "gps: $GPGLL,,,,,,V,N",
|
|
|
+ "$GPXTE,A,A,0.67,L,N*6e",
|
|
|
+ "$GPXTE,A,A,0.67,L,N*6g",
|
|
|
+ "$GPTXT,hello\n ",
|
|
|
+ "$GPTXT,hello\r*24",
|
|
|
+ "$GPTXT,hello\r\n$",
|
|
|
+ NULL,
|
|
|
+};
|
|
|
+
|
|
|
+START_TEST(test_minmea_checksum)
|
|
|
+{
|
|
|
+ ck_assert_int_eq(minmea_checksum(""), 0x00);
|
|
|
+ ck_assert_int_eq(minmea_checksum("$"), 0x00);
|
|
|
+ ck_assert_int_eq(minmea_checksum("*"), 0x00);
|
|
|
+ ck_assert_int_eq(minmea_checksum("$*"), 0x00);
|
|
|
+ ck_assert_int_eq(minmea_checksum("$GPTXT,01,01,02,ANTSTATUS=INIT*25"), 0x25);
|
|
|
+ ck_assert_int_eq(minmea_checksum("$GPTXT,01,01,02,ANTSTATUS=INIT"), 0x25);
|
|
|
+ ck_assert_int_eq(minmea_checksum("GPTXT,01,01,02,ANTSTATUS=INIT*25"), 0x25);
|
|
|
+ ck_assert_int_eq(minmea_checksum("GPTXT,01,01,02,ANTSTATUS=INIT"), 0x25);
|
|
|
+ ck_assert_int_eq(minmea_checksum("$GPXTE,A,A,0.67,L,N*6F"), 0x6f);
|
|
|
+ ck_assert_int_eq(minmea_checksum("GPXTE,A,A,0.67,L,N*6f"), 0x6f);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_check)
|
|
|
+{
|
|
|
+ for (const char **sentence=valid_sentences_nochecksum; *sentence; sentence++) {
|
|
|
+ ck_assert_msg(minmea_check(*sentence, false) == true, "%s", *sentence);
|
|
|
+ ck_assert_msg(minmea_check(*sentence, true) == false, "%s", *sentence);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const char **sentence=valid_sentences_checksum; *sentence; sentence++) {
|
|
|
+ ck_assert_msg(minmea_check(*sentence, false) == true, "%s", *sentence);
|
|
|
+ ck_assert_msg(minmea_check(*sentence, true) == true, "%s", *sentence);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (const char **sentence=invalid_sentences; *sentence; sentence++) {
|
|
|
+ ck_assert_msg(minmea_check(*sentence, false) == false, "%s", *sentence);
|
|
|
+ ck_assert_msg(minmea_check(*sentence, true) == false, "%s", *sentence);
|
|
|
+ }
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_c)
|
|
|
+{
|
|
|
+ char ch, extra;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("A,123.45", "c", &ch) == true);
|
|
|
+ ck_assert_int_eq(ch, 'A');
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("WUT,123.45", "c", &ch) == true);
|
|
|
+ ck_assert_int_eq(ch, 'W');
|
|
|
+
|
|
|
+ ck_assert(minmea_scan(",123.45", "c", &ch) == true);
|
|
|
+ ck_assert_int_eq(ch, '\0');
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("A,B", "cc", &ch, &extra) == true);
|
|
|
+ ck_assert_int_eq(ch, 'A');
|
|
|
+ ck_assert_int_eq(extra, 'B');
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("C", "cc", &ch, &extra) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("D", "c;c", &ch, &extra) == true);
|
|
|
+ ck_assert_int_eq(ch, 'D');
|
|
|
+ ck_assert_int_eq(extra, '\0');
|
|
|
+ ck_assert(minmea_scan("E,F", "c;c", &ch, &extra) == true);
|
|
|
+ ck_assert_int_eq(ch, 'E');
|
|
|
+ ck_assert_int_eq(extra, 'F');
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_d)
|
|
|
+{
|
|
|
+ int direction;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("K", "d", &direction) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("", "d", &direction) == true);
|
|
|
+ ck_assert(minmea_scan(",foo", "d", &direction) == true);
|
|
|
+ ck_assert_int_eq(direction, 0);
|
|
|
+ ck_assert(minmea_scan("N", "d", &direction) == true);
|
|
|
+ ck_assert_int_eq(direction, 1);
|
|
|
+ ck_assert(minmea_scan("S,foo", "d", &direction) == true);
|
|
|
+ ck_assert_int_eq(direction, -1);
|
|
|
+ ck_assert(minmea_scan("W", "d", &direction) == true);
|
|
|
+ ck_assert_int_eq(direction, -1);
|
|
|
+ ck_assert(minmea_scan("E,foo", "d", &direction) == true);
|
|
|
+ ck_assert_int_eq(direction, 1);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_f)
|
|
|
+{
|
|
|
+ struct minmea_float f;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("-", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("10-", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("+-10", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("12..45", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("blah", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("12.3.4", "f", &f) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan(",", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.scale, 0);
|
|
|
+ ck_assert(minmea_scan("", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.scale, 0);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("42", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 42);
|
|
|
+ ck_assert_int_eq(f.scale, 1);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("15.345", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 15345);
|
|
|
+ ck_assert_int_eq(f.scale, 1000);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("-1.23,V", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, -123);
|
|
|
+ ck_assert_int_eq(f.scale, 100);
|
|
|
+
|
|
|
+ /* the guaranteed range is 32 bits which translates to +-180 degrees
|
|
|
+ * with 5 decimal digits. make sure we support that. */
|
|
|
+ ck_assert(minmea_scan("18000.00000", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 1800000000);
|
|
|
+ ck_assert_int_eq(f.scale, 100000);
|
|
|
+ ck_assert(minmea_scan("-18000.00000", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, -1800000000);
|
|
|
+ ck_assert_int_eq(f.scale, 100000);
|
|
|
+
|
|
|
+ if (sizeof(int_least32_t) == 4) {
|
|
|
+ /* fits in 32 bits */
|
|
|
+ ck_assert(minmea_scan("2147483647", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 2147483647);
|
|
|
+ ck_assert_int_eq(f.scale, 1);
|
|
|
+ /* doesn't fit, truncate precision */
|
|
|
+ ck_assert(minmea_scan("2147483.648", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 214748364);
|
|
|
+ ck_assert_int_eq(f.scale, 100);
|
|
|
+ /* doesn't fit, bail out */
|
|
|
+ ck_assert(minmea_scan("2147483648", "f", &f) == false);
|
|
|
+ } else if (sizeof(int_least32_t) == 8) {
|
|
|
+ /* Casting to int64_t is ugly, but otherwise we get this on machines with 32-bit int_least32_t:
|
|
|
+ * error: comparison is always false due to limited range of data type [-Werror=type-limits] */
|
|
|
+ /* fits in 64 bits */
|
|
|
+ ck_assert(minmea_scan("9223372036854775807", "f", &f) == true);
|
|
|
+ ck_assert_int_eq((int64_t) f.value, 9223372036854775807LL);
|
|
|
+ ck_assert_int_eq(f.scale, 1);
|
|
|
+ /* doesn't fit, truncate precision */
|
|
|
+ ck_assert(minmea_scan("9223372036854775.808", "f", &f) == true);
|
|
|
+ ck_assert_int_eq((int64_t) f.value, 922337203685477580LL);
|
|
|
+ ck_assert_int_eq(f.scale, 100);
|
|
|
+ /* doesn't fit, bail out */
|
|
|
+ ck_assert(minmea_scan("9223372036854775808", "f", &f) == false);
|
|
|
+ } else {
|
|
|
+ ck_abort_msg("your platform is esoteric. please fix this unit test.");
|
|
|
+ }
|
|
|
+
|
|
|
+ /* optional f.values */
|
|
|
+ ck_assert(minmea_scan("foo", "_;f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.scale, 0);
|
|
|
+ ck_assert(minmea_scan("foo,", "_;f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.scale, 0);
|
|
|
+ ck_assert(minmea_scan("foo,12.3", "_;f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, 123);
|
|
|
+ ck_assert_int_eq(f.scale, 10);
|
|
|
+
|
|
|
+ /* accept spaces at the start of the field. some modules do this, unfortunately. */
|
|
|
+ ck_assert(minmea_scan(" -1.23,V", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, -123);
|
|
|
+ ck_assert_int_eq(f.scale, 100);
|
|
|
+ ck_assert(minmea_scan(" -4.56,V", "f", &f) == true);
|
|
|
+ ck_assert_int_eq(f.value, -456);
|
|
|
+ ck_assert_int_eq(f.scale, 100);
|
|
|
+ ck_assert(minmea_scan("-3.33 ,V", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan(" -3.33 ,V", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("-3. 33,V", "f", &f) == false);
|
|
|
+ ck_assert(minmea_scan("0 .0,V", "f", &f) == false);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_i)
|
|
|
+{
|
|
|
+ int value, extra;
|
|
|
+
|
|
|
+ // valid parses
|
|
|
+ ck_assert(minmea_scan("14", "i", &value) == true);
|
|
|
+ ck_assert_int_eq(value, 14);
|
|
|
+ ck_assert(minmea_scan("-1234", "i", &value) == true);
|
|
|
+ ck_assert_int_eq(value, -1234);
|
|
|
+
|
|
|
+ // empty field
|
|
|
+ ck_assert(minmea_scan("", "i", &value) == true);
|
|
|
+ ck_assert_int_eq(value, 0);
|
|
|
+
|
|
|
+ // invalid value
|
|
|
+ ck_assert(minmea_scan("foo", "i", &value) == false);
|
|
|
+
|
|
|
+ // missing field
|
|
|
+ ck_assert(minmea_scan("41", "ii", &value, &extra) == false);
|
|
|
+
|
|
|
+ /* optional values */
|
|
|
+ ck_assert(minmea_scan("10", "i;i", &value, &extra) == true);
|
|
|
+ ck_assert_int_eq(value, 10);
|
|
|
+ ck_assert(minmea_scan("20,30", "i;i", &value, &extra) == true);
|
|
|
+ ck_assert_int_eq(value, 20);
|
|
|
+ ck_assert_int_eq(extra, 30);
|
|
|
+ ck_assert(minmea_scan("42,foo", "i;i", &value, &extra) == false);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_s)
|
|
|
+{
|
|
|
+ char value[MINMEA_MAX_SENTENCE_LENGTH];
|
|
|
+
|
|
|
+ ck_assert(minmea_scan(",bar,baz", "s", value) == true);
|
|
|
+ ck_assert_str_eq(value, "");
|
|
|
+ ck_assert(minmea_scan("foo,bar,baz", "s", value) == true);
|
|
|
+ ck_assert_str_eq(value, "foo");
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("dummy", "_;s", value) == true);
|
|
|
+ ck_assert_str_eq(value, "");
|
|
|
+ ck_assert(minmea_scan("dummy,foo", "_;s", value) == true);
|
|
|
+ ck_assert_str_eq(value, "foo");
|
|
|
+ ck_assert(minmea_scan("dummy,", "_;s", value) == true);
|
|
|
+ ck_assert_str_eq(value, "");
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_t)
|
|
|
+{
|
|
|
+ char buf[7];
|
|
|
+ buf[sizeof(buf)-1] = 0x42;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPRM,foo,bar,baz", "t", buf) == false);
|
|
|
+ ck_assert(minmea_scan("GPRMC,foo,bar,baz", "t", buf) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPRMC,foo,bar,baz", "t", buf) == true);
|
|
|
+ ck_assert_str_eq(buf, "GPRMC");
|
|
|
+
|
|
|
+ ck_assert(buf[sizeof(buf)-1] == 0x42);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_D)
|
|
|
+{
|
|
|
+ struct minmea_date d;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,3112", "_D", &d) == false);
|
|
|
+ ck_assert(minmea_scan("$GPXXX,foobar", "_D", &d) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,311299", "_D", &d) == true);
|
|
|
+ ck_assert_int_eq(d.day, 31);
|
|
|
+ ck_assert_int_eq(d.month, 12);
|
|
|
+ ck_assert_int_eq(d.year, 99);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,,,,,,,,,nope", "_D", &d) == true);
|
|
|
+ ck_assert_int_eq(d.day, -1);
|
|
|
+ ck_assert_int_eq(d.month, -1);
|
|
|
+ ck_assert_int_eq(d.year, -1);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_T)
|
|
|
+{
|
|
|
+ struct minmea_time t;
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,2359", "_T", &t) == false);
|
|
|
+ ck_assert(minmea_scan("$GPXXX,foobar", "_T", &t) == false);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,235960", "_T", &t) == true);
|
|
|
+ ck_assert_int_eq(t.hours, 23);
|
|
|
+ ck_assert_int_eq(t.minutes, 59);
|
|
|
+ ck_assert_int_eq(t.seconds, 60);
|
|
|
+ ck_assert_int_eq(t.microseconds, 0);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,213700.001", "_T", &t) == true);
|
|
|
+ ck_assert_int_eq(t.hours, 21);
|
|
|
+ ck_assert_int_eq(t.minutes, 37);
|
|
|
+ ck_assert_int_eq(t.seconds, 0);
|
|
|
+ ck_assert_int_eq(t.microseconds, 1000);
|
|
|
+
|
|
|
+ ck_assert(minmea_scan("$GPXXX,,,,,,,nope", "_T", &t) == true);
|
|
|
+ ck_assert_int_eq(t.hours, -1);
|
|
|
+ ck_assert_int_eq(t.minutes, -1);
|
|
|
+ ck_assert_int_eq(t.seconds, -1);
|
|
|
+ ck_assert_int_eq(t.microseconds, -1);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_complex1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47\r\n";
|
|
|
+ char type[6];
|
|
|
+ struct minmea_time t;
|
|
|
+ struct minmea_float latitude; int latitude_direction;
|
|
|
+ struct minmea_float longitude; int longitude_direction;
|
|
|
+ int fix_quality;
|
|
|
+ int satellites;
|
|
|
+ struct minmea_float hdop;
|
|
|
+ struct minmea_float altitude; char altitude_units;
|
|
|
+ struct minmea_float height; char height_units;
|
|
|
+ ck_assert(minmea_scan(sentence, "tTfdfdiiffcfc__",
|
|
|
+ type,
|
|
|
+ &t,
|
|
|
+ &latitude, &latitude_direction,
|
|
|
+ &longitude, &longitude_direction,
|
|
|
+ &fix_quality,
|
|
|
+ &satellites,
|
|
|
+ &hdop,
|
|
|
+ &altitude, &altitude_units,
|
|
|
+ &height, &height_units) == true);
|
|
|
+ ck_assert_str_eq(type, "GPGGA");
|
|
|
+ ck_assert_int_eq(t.hours, 12);
|
|
|
+ ck_assert_int_eq(t.minutes, 35);
|
|
|
+ ck_assert_int_eq(t.seconds, 19);
|
|
|
+ ck_assert_int_eq(latitude.value, 4807038);
|
|
|
+ ck_assert_int_eq(latitude.scale, 1000);
|
|
|
+ ck_assert_int_eq(latitude_direction, 1);
|
|
|
+ ck_assert_int_eq(longitude.value, 1131000);
|
|
|
+ ck_assert_int_eq(longitude.scale, 1000);
|
|
|
+ ck_assert_int_eq(longitude_direction, 1);
|
|
|
+ ck_assert_int_eq(fix_quality, 1);
|
|
|
+ ck_assert_int_eq(satellites, 8);
|
|
|
+ ck_assert_int_eq(hdop.value, 9);
|
|
|
+ ck_assert_int_eq(hdop.scale, 10);
|
|
|
+ ck_assert_int_eq(altitude.value, 5454);
|
|
|
+ ck_assert_int_eq(altitude.scale, 10);
|
|
|
+ ck_assert_int_eq(altitude_units, 'M');
|
|
|
+ ck_assert_int_eq(height.value, 469);
|
|
|
+ ck_assert_int_eq(height.scale, 10);
|
|
|
+ ck_assert_int_eq(height_units, 'M');
|
|
|
+
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_complex2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPBWC,081837,,,,,,T,,M,,N,*13";
|
|
|
+ char type[6];
|
|
|
+ struct minmea_time t;
|
|
|
+ struct minmea_float latitude; int latitude_direction;
|
|
|
+ struct minmea_float longitude; int longitude_direction;
|
|
|
+ struct minmea_float bearing_true; char bearing_true_mark;
|
|
|
+ struct minmea_float bearing_magnetic; char bearing_magnetic_mark;
|
|
|
+ struct minmea_float distance; char distance_units;
|
|
|
+ char name[MINMEA_MAX_SENTENCE_LENGTH];
|
|
|
+ ck_assert(minmea_scan(sentence, "tTfdfdfcfcfcs",
|
|
|
+ type,
|
|
|
+ &t,
|
|
|
+ &latitude, &latitude_direction,
|
|
|
+ &longitude, &longitude_direction,
|
|
|
+ &bearing_true, &bearing_true_mark,
|
|
|
+ &bearing_magnetic, &bearing_magnetic_mark,
|
|
|
+ &distance, &distance_units,
|
|
|
+ name) == true);
|
|
|
+ ck_assert_str_eq(type, "GPBWC");
|
|
|
+ ck_assert_int_eq(t.hours, 8);
|
|
|
+ ck_assert_int_eq(t.minutes, 18);
|
|
|
+ ck_assert_int_eq(t.seconds, 37);
|
|
|
+ ck_assert_int_eq(latitude.scale, 0);
|
|
|
+ ck_assert_int_eq(latitude_direction, 0);
|
|
|
+ ck_assert_int_eq(longitude.scale, 0);
|
|
|
+ ck_assert_int_eq(longitude_direction, 0);
|
|
|
+ ck_assert_int_eq(bearing_true.scale, 0);
|
|
|
+ ck_assert_int_eq(bearing_true_mark, 'T');
|
|
|
+ ck_assert_int_eq(bearing_magnetic.scale, 0);
|
|
|
+ ck_assert_int_eq(bearing_magnetic_mark, 'M');
|
|
|
+ ck_assert_int_eq(distance.scale, 0);
|
|
|
+ ck_assert_int_eq(distance_units, 'N');
|
|
|
+ ck_assert_str_eq(name, "");
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_scan_complex3)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58";
|
|
|
+ char type[6];
|
|
|
+ struct minmea_time t;
|
|
|
+ struct minmea_float rms_deviation;
|
|
|
+ struct minmea_float semi_major_deviation;
|
|
|
+ struct minmea_float semi_minor_deviation;
|
|
|
+ struct minmea_float semi_major_orientation;
|
|
|
+ struct minmea_float latitude_error_deviation;
|
|
|
+ struct minmea_float longitude_error_deviation;
|
|
|
+ struct minmea_float altitude_error_deviation;
|
|
|
+ ck_assert(minmea_scan(sentence, "tTfffffff",
|
|
|
+ type,
|
|
|
+ &t,
|
|
|
+ &rms_deviation,
|
|
|
+ &semi_major_deviation,
|
|
|
+ &semi_minor_deviation,
|
|
|
+ &semi_major_orientation,
|
|
|
+ &latitude_error_deviation,
|
|
|
+ &longitude_error_deviation,
|
|
|
+ &altitude_error_deviation) == true);
|
|
|
+ ck_assert_str_eq(type, "GPGST");
|
|
|
+ ck_assert_int_eq(t.hours, 2);
|
|
|
+ ck_assert_int_eq(t.minutes, 46);
|
|
|
+ ck_assert_int_eq(t.seconds, 3);
|
|
|
+ ck_assert_int_eq(t.microseconds, 0);
|
|
|
+ ck_assert_int_eq(rms_deviation.value, 32);
|
|
|
+ ck_assert_int_eq(rms_deviation.scale, 10);
|
|
|
+ ck_assert_int_eq(semi_major_deviation.value, 66);
|
|
|
+ ck_assert_int_eq(semi_major_deviation.scale, 10);
|
|
|
+ ck_assert_int_eq(semi_minor_deviation.value, 47);
|
|
|
+ ck_assert_int_eq(semi_minor_deviation.scale, 10);
|
|
|
+ ck_assert_int_eq(semi_major_orientation.value, 473);
|
|
|
+ ck_assert_int_eq(semi_major_orientation.scale, 10);
|
|
|
+ ck_assert_int_eq(latitude_error_deviation.value, 58);
|
|
|
+ ck_assert_int_eq(latitude_error_deviation.scale, 10);
|
|
|
+ ck_assert_int_eq(longitude_error_deviation.value, 56);
|
|
|
+ ck_assert_int_eq(longitude_error_deviation.scale, 10);
|
|
|
+ ck_assert_int_eq(altitude_error_deviation.value, 220);
|
|
|
+ ck_assert_int_eq(altitude_error_deviation.scale, 10);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gbs1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GNGBS,170556.00,3.0,2.9,8.3,,,,";
|
|
|
+ struct minmea_sentence_gbs frame = {};
|
|
|
+ static const struct minmea_sentence_gbs expected = {
|
|
|
+ .time = { 17, 5, 56, 0 },
|
|
|
+ .err_latitude = { 30, 10 },
|
|
|
+ .err_longitude = { 29, 10 },
|
|
|
+ .err_altitude = { 83, 10 },
|
|
|
+ .svid = 0,
|
|
|
+ .prob = { 0, 0 },
|
|
|
+ .bias = { 0, 0 },
|
|
|
+ .stddev = { 0, 0 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == false);
|
|
|
+ ck_assert(minmea_parse_gbs(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gbs2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGBS,015509.00,-0.031,-0.186,0.219,19,0.000,-0.354,6.972*4D";
|
|
|
+ struct minmea_sentence_gbs frame = {};
|
|
|
+ static const struct minmea_sentence_gbs expected = {
|
|
|
+ .time = { 1, 55, 9 },
|
|
|
+ .err_latitude = { -31, 1000 },
|
|
|
+ .err_longitude = { -186, 1000 },
|
|
|
+ .err_altitude = { 219, 1000 },
|
|
|
+ .svid = 19,
|
|
|
+ .prob = { 0, 1000 },
|
|
|
+ .bias = { -354, 1000 },
|
|
|
+ .stddev = { 6972, 1000 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gbs(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_rmc1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPRMC,081836.75,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E";
|
|
|
+ struct minmea_sentence_rmc frame = {};
|
|
|
+ static const struct minmea_sentence_rmc expected = {
|
|
|
+ .time = { 8, 18, 36, 750000 },
|
|
|
+ .valid = true,
|
|
|
+ .latitude = { -375165, 100 },
|
|
|
+ .longitude = { 1450736, 100 },
|
|
|
+ .speed = { 0, 10 },
|
|
|
+ .course = { 3600, 10 },
|
|
|
+ .date = { 13, 9, 98 },
|
|
|
+ .variation = { 113, 10 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == false);
|
|
|
+ ck_assert(minmea_parse_rmc(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_rmc2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPRMC,,A,3751.65,N,14507.36,W,,,,,";
|
|
|
+ struct minmea_sentence_rmc frame = {};
|
|
|
+ static const struct minmea_sentence_rmc expected = {
|
|
|
+ .time = { -1, -1, -1, -1 },
|
|
|
+ .valid = true,
|
|
|
+ .latitude = { 375165, 100 },
|
|
|
+ .longitude = { -1450736, 100 },
|
|
|
+ .date = { -1, -1, -1 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == false);
|
|
|
+ ck_assert(minmea_parse_rmc(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gga1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47";
|
|
|
+ struct minmea_sentence_gga frame = {};
|
|
|
+ struct minmea_sentence_gga expected = {};
|
|
|
+ expected.time = (struct minmea_time) { 12, 35, 19, 0 };
|
|
|
+ expected.latitude = (struct minmea_float) { 4807038, 1000 };
|
|
|
+ expected.longitude = (struct minmea_float) { 1131000, 1000 };
|
|
|
+ expected.fix_quality = 1;
|
|
|
+ expected.satellites_tracked = 8;
|
|
|
+ expected.hdop = (struct minmea_float) { 9, 10 };
|
|
|
+ expected.altitude = (struct minmea_float) { 5454, 10 };
|
|
|
+ expected.altitude_units = 'M';
|
|
|
+ expected.height = (struct minmea_float) { 469, 10 };
|
|
|
+ expected.height_units = 'M';
|
|
|
+ expected.dgps_age = (struct minmea_float) { 0, 0 };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gga(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gst1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58";
|
|
|
+ struct minmea_sentence_gst frame = {};
|
|
|
+ struct minmea_sentence_gst expected = {
|
|
|
+ .time = { 2, 46, 3, 0 },
|
|
|
+ .rms_deviation = { 32, 10 },
|
|
|
+ .semi_major_deviation = { 66, 10 },
|
|
|
+ .semi_minor_deviation = { 47, 10 },
|
|
|
+ .semi_major_orientation = { 473, 10 },
|
|
|
+ .latitude_error_deviation = { 58, 10 },
|
|
|
+ .longitude_error_deviation = { 56, 10 },
|
|
|
+ .altitude_error_deviation = { 220, 10 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gst(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsa1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39";
|
|
|
+ struct minmea_sentence_gsa frame = {};
|
|
|
+ static const struct minmea_sentence_gsa expected = {
|
|
|
+ .mode = MINMEA_GPGSA_MODE_AUTO,
|
|
|
+ .fix_type = MINMEA_GPGSA_FIX_3D,
|
|
|
+ .sats = { 4, 5, 0, 9, 12, 0, 0, 24, 0, 0, 0, 0 },
|
|
|
+ .pdop = { 25, 10 },
|
|
|
+ .hdop = { 13, 10 },
|
|
|
+ .vdop = { 21, 10 },
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsa(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gll1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41";
|
|
|
+ struct minmea_sentence_gll frame;
|
|
|
+ struct minmea_sentence_gll expected;
|
|
|
+
|
|
|
+ // clear structs before initialization to enable use of memcmp()
|
|
|
+ // todo: add for other structs
|
|
|
+ memset(&frame, 0, sizeof(frame));
|
|
|
+ memset(&expected, 0, sizeof(expected));
|
|
|
+
|
|
|
+ expected.latitude = (struct minmea_float){ 37232475, 10000 };
|
|
|
+ expected.longitude = (struct minmea_float){ -121583416, 10000 };
|
|
|
+ expected.time = (struct minmea_time){ 16, 12, 29, 487000 };
|
|
|
+ expected.status = MINMEA_GLL_STATUS_DATA_VALID;
|
|
|
+ expected.mode = MINMEA_FAA_MODE_AUTONOMOUS;
|
|
|
+
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gll(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gll2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGLL,4916.45,N,12311.12,W,225444,A";
|
|
|
+ struct minmea_sentence_gll frame = {};
|
|
|
+ struct minmea_sentence_gll expected = {
|
|
|
+ .latitude = { 491645, 100 },
|
|
|
+ .longitude = { -1231112, 100 },
|
|
|
+ .time = { 22, 54, 44 },
|
|
|
+ .status = MINMEA_GLL_STATUS_DATA_VALID,
|
|
|
+ .mode = 0,
|
|
|
+ };
|
|
|
+
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == false);
|
|
|
+ ck_assert(minmea_parse_gll(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsv1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D";
|
|
|
+ struct minmea_sentence_gsv frame = {};
|
|
|
+ static const struct minmea_sentence_gsv expected = {
|
|
|
+ .total_msgs = 3,
|
|
|
+ .msg_nr = 3,
|
|
|
+ .total_sats = 11,
|
|
|
+ .sats = {
|
|
|
+ {
|
|
|
+ .nr = 22,
|
|
|
+ .elevation = 42,
|
|
|
+ .azimuth = 67,
|
|
|
+ .snr = 42
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 24,
|
|
|
+ .elevation = 14,
|
|
|
+ .azimuth = 311,
|
|
|
+ .snr = 43
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 27,
|
|
|
+ .elevation = 5,
|
|
|
+ .azimuth = 244,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsv(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsv2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSV,4,2,11,08,51,203,30,09,45,215,28*75";
|
|
|
+ struct minmea_sentence_gsv frame = {};
|
|
|
+ static const struct minmea_sentence_gsv expected = {
|
|
|
+ .total_msgs = 4,
|
|
|
+ .msg_nr = 2,
|
|
|
+ .total_sats = 11,
|
|
|
+ .sats = {
|
|
|
+ {
|
|
|
+ .nr = 8,
|
|
|
+ .elevation = 51,
|
|
|
+ .azimuth = 203,
|
|
|
+ .snr = 30
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 9,
|
|
|
+ .elevation = 45,
|
|
|
+ .azimuth = 215,
|
|
|
+ .snr = 28
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsv(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsv3)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSV,4,4,13,39,31,170,27*40";
|
|
|
+ struct minmea_sentence_gsv frame = {};
|
|
|
+ static const struct minmea_sentence_gsv expected = {
|
|
|
+ .total_msgs = 4,
|
|
|
+ .msg_nr = 4,
|
|
|
+ .total_sats = 13,
|
|
|
+ .sats = {
|
|
|
+ {
|
|
|
+ .nr = 39,
|
|
|
+ .elevation = 31,
|
|
|
+ .azimuth = 170,
|
|
|
+ .snr = 27
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsv(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsv4)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSV,4,4,13*7B";
|
|
|
+ struct minmea_sentence_gsv frame = {};
|
|
|
+ static const struct minmea_sentence_gsv expected = {
|
|
|
+ .total_msgs = 4,
|
|
|
+ .msg_nr = 4,
|
|
|
+ .total_sats = 13,
|
|
|
+ .sats = {
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 0,
|
|
|
+ .elevation = 0,
|
|
|
+ .azimuth = 0,
|
|
|
+ .snr = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsv(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_gsv5)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPGSV,4,1,13,02,28,259,33,04,12,212,27,05,34,305,30,07,79,138,*7F";
|
|
|
+ struct minmea_sentence_gsv frame = {};
|
|
|
+ static const struct minmea_sentence_gsv expected = {
|
|
|
+ .total_msgs = 4,
|
|
|
+ .msg_nr = 1,
|
|
|
+ .total_sats = 13,
|
|
|
+ .sats = {
|
|
|
+ {
|
|
|
+ .nr = 2,
|
|
|
+ .elevation = 28,
|
|
|
+ .azimuth = 259,
|
|
|
+ .snr = 33
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 4,
|
|
|
+ .elevation = 12,
|
|
|
+ .azimuth = 212,
|
|
|
+ .snr = 27
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 5,
|
|
|
+ .elevation = 34,
|
|
|
+ .azimuth = 305,
|
|
|
+ .snr = 30
|
|
|
+ },
|
|
|
+ {
|
|
|
+ .nr = 7,
|
|
|
+ .elevation = 79,
|
|
|
+ .azimuth = 138,
|
|
|
+ .snr = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_gsv(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_vtg1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48";
|
|
|
+ // clear structs before initialization to enable use of memcmp()
|
|
|
+ struct minmea_sentence_vtg frame = {};
|
|
|
+ struct minmea_sentence_vtg expected = {};
|
|
|
+
|
|
|
+ expected = (struct minmea_sentence_vtg){
|
|
|
+ .true_track_degrees = { 547, 10 },
|
|
|
+ .magnetic_track_degrees = { 344, 10 },
|
|
|
+ .speed_knots = { 55, 10 },
|
|
|
+ .speed_kph = { 102, 10 },
|
|
|
+ .faa_mode = 0,
|
|
|
+ };
|
|
|
+
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_vtg(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_vtg2)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPVTG,188.36,T,,M,0.820,N,1.519,K,A*3F";
|
|
|
+ // clear structs before initialization to enable use of memcmp()
|
|
|
+ struct minmea_sentence_vtg frame = {};
|
|
|
+ struct minmea_sentence_vtg expected = {};
|
|
|
+
|
|
|
+ expected = (struct minmea_sentence_vtg){
|
|
|
+ .true_track_degrees = { 18836, 100 },
|
|
|
+ .magnetic_track_degrees = { 0, 0 },
|
|
|
+ .speed_knots = { 820, 1000 },
|
|
|
+ .speed_kph = { 1519, 1000 },
|
|
|
+ .faa_mode = MINMEA_FAA_MODE_AUTONOMOUS,
|
|
|
+ };
|
|
|
+
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_vtg(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_vtg3)
|
|
|
+{
|
|
|
+ // https://github.com/kosma/minmea/issues/57
|
|
|
+ const char *sentence = "$GNVTG,,,,,,,,,N*2E";
|
|
|
+ // clear structs before initialization to enable use of memcmp()
|
|
|
+ struct minmea_sentence_vtg frame = {};
|
|
|
+ struct minmea_sentence_vtg expected = {};
|
|
|
+ expected = (struct minmea_sentence_vtg){
|
|
|
+ .true_track_degrees = { 0, 0 },
|
|
|
+ .magnetic_track_degrees = { 0, 0 },
|
|
|
+ .speed_knots = { 0, 0 },
|
|
|
+ .speed_kph = { 0, 0 },
|
|
|
+ .faa_mode = MINMEA_FAA_MODE_NOT_VALID,
|
|
|
+ };
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_vtg(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_parse_zda1)
|
|
|
+{
|
|
|
+ const char *sentence = "$GPZDA,160012.71,11,03,2004,-1,00*7D";
|
|
|
+ struct minmea_sentence_zda frame = {};
|
|
|
+ struct minmea_sentence_zda expected = {};
|
|
|
+
|
|
|
+ expected = (struct minmea_sentence_zda) {
|
|
|
+ .time = { 16, 0, 12, 710000 },
|
|
|
+ .date = { 11, 3, 2004 },
|
|
|
+ .hour_offset = -1,
|
|
|
+ .minute_offset = 0,
|
|
|
+ };
|
|
|
+
|
|
|
+ ck_assert(minmea_check(sentence, false) == true);
|
|
|
+ ck_assert(minmea_check(sentence, true) == true);
|
|
|
+ ck_assert(minmea_parse_zda(&frame, sentence) == true);
|
|
|
+ ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_usage1)
|
|
|
+{
|
|
|
+ const char *sentences[] = {
|
|
|
+ "$GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62",
|
|
|
+ "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47",
|
|
|
+ "$GNGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1",
|
|
|
+ "$GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41",
|
|
|
+ "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58",
|
|
|
+ "$GPVTG,096.5,T,083.5,M,0.0,N,0.0,K,D*22",
|
|
|
+ NULL,
|
|
|
+ };
|
|
|
+
|
|
|
+ for (const char **sentence=sentences; *sentence; sentence++) {
|
|
|
+ switch (minmea_sentence_id(*sentence, false)) {
|
|
|
+ case MINMEA_SENTENCE_RMC: {
|
|
|
+ struct minmea_sentence_rmc frame;
|
|
|
+ ck_assert(minmea_parse_rmc(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case MINMEA_SENTENCE_GGA: {
|
|
|
+ struct minmea_sentence_gga frame;
|
|
|
+ ck_assert(minmea_parse_gga(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case MINMEA_SENTENCE_GSA: {
|
|
|
+ struct minmea_sentence_gsa frame;
|
|
|
+ ck_assert(minmea_parse_gsa(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case MINMEA_SENTENCE_GLL: {
|
|
|
+ struct minmea_sentence_gll frame;
|
|
|
+ ck_assert(minmea_parse_gll(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case MINMEA_SENTENCE_GST: {
|
|
|
+ struct minmea_sentence_gst frame;
|
|
|
+ ck_assert(minmea_parse_gst(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case MINMEA_SENTENCE_VTG: {
|
|
|
+ struct minmea_sentence_vtg frame;
|
|
|
+ ck_assert(minmea_parse_vtg(&frame, *sentence) == true);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ default: {
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+
|
|
|
+ char talker[3];
|
|
|
+ char expected[3] = { (*sentence)[1], (*sentence)[2], '\0' };
|
|
|
+ ck_assert(minmea_talker_id(talker, *sentence) == true);
|
|
|
+ ck_assert_str_eq(talker, expected);
|
|
|
+ }
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_gettime)
|
|
|
+{
|
|
|
+ struct minmea_date d = { 14, 2, 14 };
|
|
|
+ struct minmea_time t = { 13, 0, 9, 123456 };
|
|
|
+ struct tm tm;
|
|
|
+ struct timespec ts;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2014-1900);
|
|
|
+ ck_assert_int_eq(tm.tm_mon, 1);
|
|
|
+ ck_assert_int_eq(tm.tm_mday, 14);
|
|
|
+ ck_assert_int_eq(tm.tm_hour, 13);
|
|
|
+ ck_assert_int_eq(tm.tm_min, 0);
|
|
|
+ ck_assert_int_eq(tm.tm_sec, 9);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 1392382809);
|
|
|
+ ck_assert_int_eq(ts.tv_nsec, 123456000);
|
|
|
+
|
|
|
+ d.year = -1;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) != 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) != 0);
|
|
|
+ d.year = 14;
|
|
|
+
|
|
|
+ t.hours = -1;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) != 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) != 0);
|
|
|
+ t.hours = 13;
|
|
|
+
|
|
|
+ /* two digit year conversions */
|
|
|
+ d.year = 80;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 1980-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 319381209); /* 1980 */
|
|
|
+ d.year = 37;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2037-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 2118229209); /* 2037 */
|
|
|
+ /* skip >= 2038 tests on 32-bit time_t platforms */
|
|
|
+ if (sizeof(time_t) == sizeof(int64_t)) {
|
|
|
+ d.year = 79;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2079-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 3443605209); /* 2079 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* four digit year conversions */
|
|
|
+ d.year = 1979;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 1979-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 287845209);
|
|
|
+ d.year = 1980;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 1980-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 319381209);
|
|
|
+ d.year = 2037;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2037-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 2118229209);
|
|
|
+ /* skip >= 2038 tests on 32-bit time_t platforms */
|
|
|
+ if (sizeof(time_t) == sizeof(int64_t)) {
|
|
|
+ d.year = 2079;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2079-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 3443605209);
|
|
|
+ d.year = 2080;
|
|
|
+ ck_assert(minmea_getdatetime(&tm, &d, &t) == 0);
|
|
|
+ ck_assert(minmea_gettime(&ts, &d, &t) == 0);
|
|
|
+ ck_assert_int_eq(tm.tm_year, 2080-1900);
|
|
|
+ ck_assert_int_eq(ts.tv_sec, 3475141209);
|
|
|
+ }
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_rescale)
|
|
|
+{
|
|
|
+ /* basic and edge cases. */
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 42, 0 }, 3), 0);
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1234, 10 }, 1), 123);
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1235, 10 }, 1), 124);
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1234, 10 }, 1000), 123400);
|
|
|
+
|
|
|
+ /* round towards zero. */
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1234, 10 }, 1), -123);
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1235, 10 }, 1), -124);
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1236, 10 }, 1), -124);
|
|
|
+
|
|
|
+ /* shouldn't overflow on large numbers. */
|
|
|
+ ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 510693608, 100000 }, 10000), 51069361);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+/* The float values used in tests should be exactly representable under IEEE754;
|
|
|
+ * false negatives will occur otherwise. */
|
|
|
+
|
|
|
+#define assert_float_eq(x, y) ck_assert(fabsf((x) - (y)) <= 0.0f)
|
|
|
+
|
|
|
+START_TEST(test_minmea_float)
|
|
|
+{
|
|
|
+ ck_assert(isnan(minmea_tofloat(&(struct minmea_float) { 42, 0 })));
|
|
|
+ assert_float_eq(minmea_tofloat(&(struct minmea_float) { 7, 1 }), 7.0f);
|
|
|
+ assert_float_eq(minmea_tofloat(&(struct minmea_float) { -200, 100 }), -2.0f);
|
|
|
+ assert_float_eq(minmea_tofloat(&(struct minmea_float) { 15, 10 }), 1.5f);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+START_TEST(test_minmea_coord)
|
|
|
+{
|
|
|
+ ck_assert(isnan(minmea_tocoord(&(struct minmea_float) { 42, 0 })));
|
|
|
+ assert_float_eq(minmea_tocoord(&(struct minmea_float) { 4200, 1 }), 42.0f);
|
|
|
+ assert_float_eq(minmea_tocoord(&(struct minmea_float) { 420000, 100 }), 42.0f);
|
|
|
+ assert_float_eq(minmea_tocoord(&(struct minmea_float) { 423000, 100 }), 42.5f);
|
|
|
+}
|
|
|
+END_TEST
|
|
|
+
|
|
|
+static Suite *minmea_suite(void)
|
|
|
+{
|
|
|
+ Suite *s = suite_create ("minmea");
|
|
|
+
|
|
|
+ TCase *tc_checksum = tcase_create("minmea_checksum");
|
|
|
+ tcase_add_test(tc_checksum, test_minmea_checksum);
|
|
|
+ suite_add_tcase(s, tc_checksum);
|
|
|
+
|
|
|
+ TCase *tc_check = tcase_create("minmea_check");
|
|
|
+ tcase_add_test(tc_check, test_minmea_check);
|
|
|
+ suite_add_tcase(s, tc_check);
|
|
|
+
|
|
|
+ TCase *tc_scan = tcase_create("minmea_scan");
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_c);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_d);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_f);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_i);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_s);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_t);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_D);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_T);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_complex1);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_complex2);
|
|
|
+ tcase_add_test(tc_scan, test_minmea_scan_complex3);
|
|
|
+ suite_add_tcase(s, tc_scan);
|
|
|
+
|
|
|
+ TCase *tc_parse = tcase_create("minmea_parse");
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gbs1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gbs2);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_rmc1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_rmc2);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gga1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsa1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gll1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gll2);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gst1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsv1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsv2);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsv3);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsv4);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_gsv5);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_vtg1);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_vtg2);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_vtg3);
|
|
|
+ tcase_add_test(tc_parse, test_minmea_parse_zda1);
|
|
|
+ suite_add_tcase(s, tc_parse);
|
|
|
+
|
|
|
+ TCase *tc_usage = tcase_create("minmea_usage");
|
|
|
+ tcase_add_test(tc_usage, test_minmea_usage1);
|
|
|
+ suite_add_tcase(s, tc_usage);
|
|
|
+
|
|
|
+ TCase *tc_utils = tcase_create("minmea_utils");
|
|
|
+ tcase_add_test(tc_utils, test_minmea_gettime);
|
|
|
+ tcase_add_test(tc_utils, test_minmea_rescale);
|
|
|
+ tcase_add_test(tc_utils, test_minmea_float);
|
|
|
+ tcase_add_test(tc_utils, test_minmea_coord);
|
|
|
+ suite_add_tcase(s, tc_utils);
|
|
|
+
|
|
|
+ return s;
|
|
|
+}
|
|
|
+
|
|
|
+int main(void)
|
|
|
+{
|
|
|
+ int number_failed;
|
|
|
+ Suite *s = minmea_suite();
|
|
|
+ SRunner *sr = srunner_create(s);
|
|
|
+ srunner_run_all(sr, CK_NORMAL);
|
|
|
+ number_failed = srunner_ntests_failed(sr);
|
|
|
+ srunner_free(sr);
|
|
|
+ return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
|
+}
|
|
|
+
|
|
|
+/* vim: set ts=4 sw=4 et: */
|
MX
