test/nmea/Test_nmea.cpp

   1 #include <marnav/nmea/nmea.hpp>
   2 #include <marnav/nmea/checksum.hpp>
   3 #include <marnav/nmea/detail.hpp>
   4 #include <marnav/nmea/sentence.hpp>
   5 #include <marnav/nmea/vwr.hpp>
   6 #include <gtest/gtest.h>
   7
   8 namespace
   9 {
  10
  11 using namespace marnav;
  12
  13 class Test_nmea : public ::testing::Test
  14 {
  15 };
  16
  17 TEST_F(Test_nmea, checksum_to_string)
  18 {
  19         EXPECT_STREQ("00", nmea::checksum_to_string(0x00).c_str());
  20         EXPECT_STREQ("01", nmea::checksum_to_string(0x01).c_str());
  21         EXPECT_STREQ("02", nmea::checksum_to_string(0x02).c_str());
  22         EXPECT_STREQ("04", nmea::checksum_to_string(0x04).c_str());
  23         EXPECT_STREQ("08", nmea::checksum_to_string(0x08).c_str());
  24         EXPECT_STREQ("10", nmea::checksum_to_string(0x10).c_str());
  25         EXPECT_STREQ("20", nmea::checksum_to_string(0x20).c_str());
  26         EXPECT_STREQ("40", nmea::checksum_to_string(0x40).c_str());
  27         EXPECT_STREQ("80", nmea::checksum_to_string(0x80).c_str());
  28         EXPECT_STREQ("5A", nmea::checksum_to_string(0x5a).c_str());
  29         EXPECT_STREQ("A5", nmea::checksum_to_string(0xa5).c_str());
  30         EXPECT_STREQ("FF", nmea::checksum_to_string(0xff).c_str());
  31 }
  32
  33 TEST_F(Test_nmea, make_sentence_empty_string)
  34 {
  35         EXPECT_ANY_THROW(nmea::make_sentence(""));
  36 }
  37
  38 TEST_F(Test_nmea, make_sentence_no_start_token)
  39 {
  40         EXPECT_ANY_THROW(nmea::make_sentence("1234567890"));
  41 }
  42
  43 TEST_F(Test_nmea, make_sentence_to_short)
  44 {
  45         EXPECT_ANY_THROW(nmea::make_sentence("12"));
  46 }
  47
  48 TEST_F(Test_nmea, make_sentence_no_end_token)
  49 {
  50         EXPECT_ANY_THROW(nmea::make_sentence("$GPMTW,,1E"));
  51 }
  52
  53 TEST_F(Test_nmea, make_sentence_invalid_checksum)
  54 {
  55         EXPECT_ANY_THROW(nmea::make_sentence("$GPMTW,,*1E"));
  56 }
  57
  58 TEST_F(Test_nmea, make_sentence_minimal_possible_sentence)
  59 {
  60         try {
  61                 nmea::make_sentence("$IIYYY*59");
  62         } catch (std::exception & e) {
  63                 EXPECT_STREQ("unknown regular tag in address: [IIYYY]", e.what());
  64         }
  65 }
  66
  67 TEST_F(Test_nmea, make_sentence_vendor_extension)
  68 {
  69         try {
  70                 nmea::make_sentence("$PXXX*08");
  71         } catch (std::exception & e) {
  72                 EXPECT_STREQ("unknown or malformed address field: [PXXX]", e.what());
  73         }
  74 }
  75
  76 TEST_F(Test_nmea, make_sentence_invalid_checksum_what)
  77 {
  78         try {
  79                 nmea::make_sentence("$GPMTW,,*1E");
  80         } catch (nmea::checksum_error & e) {
  81                 EXPECT_STREQ("checksum error (actual:59, expected:1E)", e.what());
  82         }
  83 }
  84
  85 TEST_F(Test_nmea, make_sentence_unknown_sentence)
  86 {
  87         EXPECT_ANY_THROW(nmea::make_sentence("$XX???,1,2,3*23"));
  88 }
  89
  90 TEST_F(Test_nmea, make_sentence_ignoring_checksum_ignored)
  91 {
  92         const std::string raw = "$IIVWR,084.0,R,10.4,N,5.4,M,19.3,K*4A";
  93
  94         auto s = nmea::make_sentence(raw, nmea::checksum_handling::ignore);
  95
  96         EXPECT_TRUE(s != nullptr);
  97         EXPECT_TRUE(s->tag() == "VWR");
  98 }
  99
 100 TEST_F(Test_nmea, make_sentence_ignoring_checksum_equal)
 101 {
 102         const std::string raw_1 = "$IIVWR,084.0,R,10.4,N,5.4,M,19.3,K*4A";
 103         const std::string raw_2 = "$IIVWR,084.0,R,10.4,N,5.4,M,19.3,K*00";
 104
 105         auto s1 = nmea::make_sentence(raw_1, nmea::checksum_handling::check);
 106         auto s2 = nmea::make_sentence(raw_2, nmea::checksum_handling::ignore);
 107
 108         ASSERT_TRUE(s1 != nullptr);
 109         ASSERT_TRUE(s2 != nullptr);
 110         EXPECT_TRUE(s1->tag() == s2->tag());
 111 }
 112
 113 TEST_F(Test_nmea, get_supported_sentences_str)
 114 {
 115         auto v = nmea::get_supported_sentences_str();
 116
 117         EXPECT_EQ(85u, v.size());
 118 }
 119
 120 TEST_F(Test_nmea, get_supported_sentences_id)
 121 {
 122         auto v = nmea::get_supported_sentences_id();
 123
 124         EXPECT_EQ(85u, v.size());
 125 }
 126
 127 TEST_F(Test_nmea, tag_to_id)
 128 {
 129         auto id = nmea::tag_to_id("BOD");
 130
 131         EXPECT_EQ(nmea::sentence_id::BOD, id);
 132 }
 133
 134 TEST_F(Test_nmea, tag_to_id_invalid_tag)
 135 {
 136         EXPECT_ANY_THROW(nmea::tag_to_id("???"));
 137 }
 138
 139 TEST_F(Test_nmea, to_string_sentence_id)
 140 {
 141         auto tag = nmea::to_string(nmea::sentence_id::BOD);
 142
 143         EXPECT_STREQ("BOD", tag.c_str());
 144 }
 145
 146 TEST_F(Test_nmea, to_string_sentence_id_invalid_id)
 147 {
 148         EXPECT_ANY_THROW(nmea::to_string(static_cast<nmea::sentence_id>(-1)));
 149 }
 150
 151 TEST_F(Test_nmea, extract_id)
 152 {
 153         EXPECT_EQ(nmea::sentence_id::BOD, nmea::extract_id("$GPBOD,,T,,M,,*47"));
 154         EXPECT_ANY_THROW(nmea::extract_id(""));
 155         EXPECT_ANY_THROW(nmea::extract_id("$"));
 156         EXPECT_ANY_THROW(nmea::extract_id("XGPBOD,,T,,M,,*47"));
 157         EXPECT_NO_THROW(nmea::extract_id("$GPBOD,,T,,M,,*XX"));
 158         EXPECT_NO_THROW(nmea::extract_id("!GPBOD,,T,,M,,*XX"));
 159         EXPECT_NO_THROW(nmea::extract_id("$GPBOD,"));
 160         EXPECT_ANY_THROW(nmea::extract_id("$GPBOD"));
 161         EXPECT_ANY_THROW(nmea::extract_id("$TMVTD"));
 162         EXPECT_ANY_THROW(nmea::extract_id("$TMVTD,,T,,M,,*47"));
 163 }
 164
 165 TEST_F(Test_nmea, extract_id_tag_block)
 166 {
 167         static const std::string t = "\\g:1-2-73874,n:157036,s:r003669945,c:1241544035*4A\\!AIVDM,"
 168                                                                  "1,1,,B,15N4cJ`005Jrek0H@9n`DW5608EP,0*13";
 169
 170         EXPECT_NO_THROW(nmea::extract_id(t));
 171         EXPECT_EQ(nmea::sentence_id::VDM, nmea::extract_id(t));
 172 }
 173
 174 TEST_F(Test_nmea, make_sentence_tag_block)
 175 {
 176         static const std::string t = "\\g:1-2-73874,n:157036,s:r003669945,c:1241544035*4A\\!AIVDM,"
 177                                                                  "1,1,,B,15N4cJ`005Jrek0H@9n`DW5608EP,0*13";
 178
 179         const auto s = nmea::make_sentence(t);
 180
 181         EXPECT_TRUE(s != nullptr);
 182         EXPECT_TRUE(!s->get_tag_block().empty());
 183         EXPECT_STREQ(
 184                 "g:1-2-73874,n:157036,s:r003669945,c:1241544035*4A", s->get_tag_block().c_str());
 185 }
 186
 187 TEST_F(Test_nmea, parse_address_empty_string)
 188 {
 189         EXPECT_ANY_THROW(nmea::detail::parse_address(std::string{}));
 190 }
 191
 192 TEST_F(Test_nmea, parse_address_regular)
 193 {
 194         EXPECT_NO_THROW(nmea::detail::parse_address("GPAAM"));
 195 }
 196
 197 TEST_F(Test_nmea, parse_address_proprietary)
 198 {
 199         {
 200                 const auto result = nmea::detail::parse_address("PGRMZ");
 201                 EXPECT_EQ(nmea::talker::none, std::get<0>(result));
 202                 EXPECT_STREQ("PGRMZ", std::get<1>(result).c_str());
 203         }
 204         {
 205                 const auto result = nmea::detail::parse_address("PGRMM");
 206                 EXPECT_EQ(nmea::talker::none, std::get<0>(result));
 207                 EXPECT_STREQ("PGRMM", std::get<1>(result).c_str());
 208         }
 209         {
 210                 EXPECT_ANY_THROW(nmea::detail::parse_address("TMVTD"));
 211         }
 212         {
 213                 EXPECT_ANY_THROW(nmea::detail::parse_address("XXYYY"));
 214         }
 215 }
 216
 217 TEST_F(Test_nmea, parse_address_proprietary_unknown)
 218 {
 219         try {
 220                 nmea::detail::parse_address("PFOOBAR");
 221         } catch (std::invalid_argument & e) {
 222                 EXPECT_STREQ("unknown or malformed address field: [PFOOBAR]", e.what());
 223         }
 224 }
 225
 226 TEST_F(Test_nmea, parse_address_regular_invalid_length)
 227 {
 228         try {
 229                 nmea::detail::parse_address("GPFOOBAR");
 230         } catch (std::invalid_argument & e) {
 231                 EXPECT_STREQ("unknown or malformed address field: [GPFOOBAR]", e.what());
 232         }
 233
 234         try {
 235                 nmea::detail::parse_address("GPRMZFOO");
 236         } catch (std::invalid_argument & e) {
 237                 EXPECT_STREQ("unknown or malformed address field: [GPRMZFOO]", e.what());
 238         }
 239 }
 240
 241 TEST_F(Test_nmea, parse_address_regular_unknown)
 242 {
 243         try {
 244                 nmea::detail::parse_address("GPXXX");
 245         } catch (std::invalid_argument & e) {
 246                 EXPECT_STREQ("unknown regular tag in address: [GPXXX]", e.what());
 247         }
 248 }
 249 }